/application/models/Question.php

https://gitlab.com/klausmig/CloudSemanticWeb · PHP · 279 lines · 261 code · 9 blank · 9 comment · 8 complexity · 1af8dc7c0fbad922f7172bc452b91484 MD5 · raw file 

    

  1. <?php
    2. 

  2. 

  3. class Question extends Model {
    4. 

  4. 	
    5. 

  5. 	public $id;
    6. 

  6. 	public $user;
    7. 

  7. 	public $item_id;
    8. 

  8.         public $item_owner;
    9. 

  9. 	public $question;
    10. 

  10. 	public $answers;
    11. 

  11. 	public $based_on;
    12. 

  12. 	public $mark;
    13. 

  13. 	public $timestamp;
    14. 

  14. 	public $guessing;
    15. 

  15. 	public $difficulty;
    16. 

  16. 	public $diff_count;
    17. 

  17. 	public $module;
    18. 

  18. 	public $diff_flag = 0;
    19. 

  19.         public $slide_revision;
    20. 

  20.         public $checked;
    21. 

  21. 

  22. 	
    23. 

  23. 	private function initConnection() {
    24. 

  24. 		// connect to db
    25. 

  25. 		if ($this->connect ( DB_DSN, DB_USER, DB_PASSWORD ) == 0)
    26. 

  26. 			die ( "Could not connect to db" );
    27. 

  27. 	}
    28. 

  28. 	public function create() {
    29. 

  29. 		$this->initConnection();                
    30. 

  30. 		$id = $this->dbInsert('questions',array('item_id'=>$this->item_id,'based_on'=>$this->based_on,'mark'=>$this->mark,'difficulty'=>$this->difficulty,'diff_count'=>$this->diff_count,'user_id'=>$this->user->id,'question'=>addslashes($this->question)));
    31. 

  31. 		return $id;
    32. 

  32. 	}
    33. 

  33. 	public function createFromID($id) {
    34. 

  34. 		$this->initConnection ();
    35. 

  35. 		$res = $this->dbGetRow ( 'SELECT * FROM questions WHERE id=:id', array ('id' => $id ) );
    36. 

  36. 		$this->id = $id;
    37. 

  37. 		$user = new User();
    38. 

  38. 		$user->createFromID($res ['user_id']);
    39. 

  39. 		$this->user = $user;
    40. 

  40. 		$this->item_id = $res ['item_id'];
    41. 

  41. 		$this->question = stripslashes($res ['question']);
    42. 

  42. 		$this->answers = $this->getAnswers();
    43. 

  43. 		$this->based_on = $res['based_on'];
    44. 

  44. 		$this->mark = $res['mark'];
    45. 

  45.                 $difficulty = $res['difficulty'];
    46. 

  46. //                if ($res['diff_count'] == NULL || $res['diff_count']<=0) $difficulty = $res['difficulty'];
    47. 

  47. //                else {
    48. 

  48. //                    $difficulty = $res['diff_count'];
    49. 

  49. //                    $this->diff_flag = 1;
    50. 

  50. //                }
    51. 

  51. 		$this->difficulty = $difficulty;
    52. 

  52. 		$this->diff_count = $res['diff_count'];
    53. 

  53. 		$this->timestamp = $res['timestamp'];
    54. 

  54. 		$this->guessing = $this->guessCount();		
    55. 

  55. 	}
    56. 

  56.         public function copy($user_id){
    57. 

  57.            $this->question = str_replace("\n"," ", $this->question);
    58. 

  58.            $this->question = str_replace("<br>"," ", $this->question);
    59. 

  59.            $id = $this->dbInsert('questions',array('item_id'=>$this->item_id,'based_on'=>$this->based_on,'mark'=>$this->mark,'difficulty'=>$this->difficulty,'diff_count'=>0,'user_id'=>$user_id,'question'=>$this->question));
    60. 

  60.            $copy = new Question();
    61. 

  61.            $copy->id = $id;
    62. 

  62.            foreach ($this->answers as $answer){
    63. 

  63.                $copy->addAnswer(stripslashes($answer['answer']), stripslashes($answer['explanation']), $answer['is_right']);
    64. 

  64.            }
    65. 

  65.            return $id;
    66. 

  66.         }
    67. 

  67.         public function delete(){
    68. 

  68.             $this->dbQuery('DELETE FROM questions WHERE id=:id',array('id'=>$this->id));
    69. 

  69.             $this->dbQuery('DELETE FROM answers WHERE question_id=:id',array('id'=>$this->id));
    70. 

  70.             $children = $this->getAllChildren();
    71. 

  71.             foreach ($children as $question){
    72. 

  72.                 $this->dbQuery('DELETE FROM questions WHERE id=:id',array('id'=>$question->id));
    73. 

  73.                 $this->dbQuery('DELETE FROM answers WHERE question_id=:id',array('id'=>$question->id));
    74. 

  74.             }
    75. 

  75.         }
    76. 

  76.         public function getFirstRevision(){
    77. 

  77.             $this->initConnection();
    78. 

  78.             if ($this->based_on > 0){
    79. 

  79.                 $question = new Question();
    80. 

  80.                 $question->createFromID($this->based_on);
    81. 

  81.                 $res = $question->getFirstRevision();
    82. 

  82.             }else $res = $this;
    83. 

  83.             return $res;
    84. 

  84.         }
    85. 

  85.         public function getFirstChildren(){
    86. 

  86.             $this->initConnection();
    87. 

  87.             $res = array();
    88. 

  88.             foreach ($this->dbQuery('SELECT id FROM questions WHERE based_on=:id', array('id'=>$this->id))as $row){
    89. 

  89.                 $res [] = $row['id'];
    90. 

  90.             }
    91. 

  91.             return $res;
    92. 

  92.         }
    93. 

  93.         public function getAllRevisions() {
    94. 

  94.             $this->initConnection();
    95. 

  95.             $result = array();
    96. 

  96.             $first = new Question();
    97. 

  97.             $first = $this->getFirstRevision();
    98. 

  98.             $sort_numcie = array();
    99. 

  99.             foreach($first->answers as $index=>$answer) {
    100. 

  100.                 $sort_numcie[] = $answer['is_right'];
    101. 

  101.             }
    102. 

  102.             array_multisort($sort_numcie, SORT_DESC, $first->answers);
    103. 

  103.             $result [] = $first;
    104. 

  104.             $result = array_merge($result, $first->getAllChildren());
    105. 

  105.             $sort_numcie = array();
    106. 

  106.             foreach($result as $index=>$question) {
    107. 

  107.                 $sort_numcie[] = $question->timestamp;
    108. 

  108.             }
    109. 

  109.             array_multisort($sort_numcie, SORT_DESC, $result);                    
    110. 

  110.             return $result;
    111. 

  111.         }
    112. 

  112.         public function getAllChildren(){
    113. 

  113.             static $result = array();
    114. 

  114.             if (count($this->getFirstChildren())){
    115. 

  115.                 foreach ($this->getFirstChildren() as $next){
    116. 

  116.                     $question = new Question();
    117. 

  117.                     $question->createFromID($next);
    118. 

  118.                     $sort_numcie = array();
    119. 

  119.                     foreach($question->answers as $index=>$answer) {
    120. 

  120.                         $sort_numcie[] = $answer['is_right'];
    121. 

  121.                     }
    122. 

  122.                     array_multisort($sort_numcie, SORT_DESC, $question->answers);
    123. 

  123.                     $result [] = $question;
    124. 

  124.                     $question->getAllChildren();
    125. 

  125.                 }
    126. 

  126.             }
    127. 

  127.             return $result;
    128. 

  128.         }
    129. 

  129.         public function useQuestRevision(){
    130. 

  130.             $this->initConnection();            
    131. 

  131.             $difficulty = $this->dbGetOne ( 'SELECT difficulty FROM questions WHERE id=:id', array ('id' => $this->id ) );
    132. 

  132.             $this->dbQuery('DELETE FROM questions WHERE id=:id',array('id'=>$this->id));
    133. 

  133.             $this->difficulty = $difficulty;
    134. 

  134.             $id = $this->dbInsert('questions',array('id'=>$this->id,'item_id'=>$this->item_id,'based_on'=>$this->based_on,'mark'=>$this->mark,'difficulty'=>$this->difficulty,'diff_count'=>$this->diff_count,'user_id'=>$this->user->id,'question'=>  addslashes($this->question)));
    135. 

  135. //            $this->dbQuery('INSERT INTO questions (id, item_id, based_on, mark, difficulty, diff_count, user_id, question) VALUES ('.$this->id .','.$this->item_id.','.$this->based_on.','.$this->mark.','.$this->difficulty.','.$this->diff_count.','.$this->user->id.','.htmlentities($this->question, ENT_QUOTES).')');
    136. 

  136.             return $this->id;
    137. 

  137.         }
    138. 

  138.         public function edit() {
    139. 

  139. 		$this->initConnection ();
    140. 

  140.                 $this->question = str_replace("\n"," ", $this->question);
    141. 

  141.                 $this->question = str_replace("<br>"," ", $this->question);
    142. 

  142.                	$this->dbQuery('UPDATE questions SET question=:question, mark=:mark, difficulty=:difficulty, diff_count=:diff_count WHERE id=:id', array ('id' => $this->id, 'mark' => $this->mark, 'question' => addslashes($this->question), 'difficulty' => $this->difficulty, 'diff_count' => $this->diff_count));
    143. 

  143. 		
    144. 

  144. 	}
    145. 

  145. 	public function getOwnerID() {
    146. 

  146. 		$this->initConnection ();
    147. 

  147. 		return $this->dbGetOne('SELECT user_id FROM questions WHERE id=' . $this->id);
    148. 

  148. 	}
    149. 

  149.         public function getItemType() {
    150. 

  150. 		$this->initConnection ();
    151. 

  151. 		return $this->dbGetOne('SELECT item_type FROM questions WHERE id=' . $this->id);
    152. 

  152. 	}
    153. 

  153.         public function getLastRevision(){	
    154. 

  154. 		$timestamp = $this->timestamp;
    155. 

  155. 		$last_id = $this->id;
    156. 

  156. 		foreach ($this->dbQuery( 'SELECT * FROM questions WHERE based_on=:id', array ('id' => $last_id ) ) as $question_row) { 
    157. 

  157. 			if ($timestamp < $question_row['timestamp']) {
    158. 

  158. 				$question = new Question();
    159. 

  159. 				$question->createFromID($question_row['id']);
    160. 

  160. 				$last_id = $question->getLastRevision();
    161. 

  161. 			}
    162. 

  162. 		}		
    163. 

  163. 		return $last_id;
    164. 

  164. 	}
    165. 

  165. 	public function addAnswer($answer,$explanation,$is_right){
    166. 

  166.             $answer = str_replace("\n"," ", $answer);
    167. 

  167.             $explanation = str_replace("\n"," ", $explanation);
    168. 

  168.             $answer = str_replace("<br>"," ", $answer);
    169. 

  169.             $explanation = str_replace("<br>"," ", $explanation);
    170. 

  170.             $res = $this->dbInsert('answers',array('question_id'=>$this->id,'answer'=>addslashes($answer), 'is_right'=>$is_right, 'explanation'=>addslashes($explanation)));
    171. 

  171.             $this->guessUpdate();
    172. 

  172.             return $res;
    173. 

  173. 	}
    174. 

  174. 	public function getAnswer($newAnswerId){
    175. 

  175. 		$res = $this->dbGetRow ( 'SELECT * FROM answers WHERE id=:id', array ( 'id' => $newAnswerId ) );
    176. 

  176.                 $res['answer'] = stripslashes($res['answer']);
    177. 

  177.                 $res['explanation'] = stripslashes($res['explanation']);
    178. 

  178. 		return $res;
    179. 

  179. 	}
    180. 

  180.         public function getAnswers() {
    181. 

  181. 		$answers = array ();
    182. 

  182. 		foreach ( $this->dbQuery ( 'SELECT id, answer, explanation, is_right FROM answers WHERE question_id=' . $this->id ) as $row ){
    183. 

  183.                     $row['answer'] = stripslashes($row['answer']);
    184. 

  184.                     $row['explanation'] = stripslashes($row['explanation']);	
    185. 

  185.                     $answers[] = $row;
    186. 

  186.                 }
    187. 

  187. 		return $answers;
    188. 

  188. 	}
    189. 

  189. 	public function getRightAnswers() {
    190. 

  190. 		$answers = array ();
    191. 

  191. 		foreach ( $this->dbQuery ( 'SELECT id, answer, explanation, is_right FROM answers WHERE question_id=' . $this->id . ' AND is_right="yes"' ) as $row ){
    192. 

  192.                     $row['answer'] = stripslashes($row['answer']);
    193. 

  193.                     $row['explanation'] = stripslashes($row['explanation']);
    194. 

  194.                     $answers[] = $row;
    195. 

  195.                         
    196. 

  196. 		}
    197. 

  197. 		return $answers;
    198. 

  198. 	}
    199. 

  199.         public function getDistractors(){
    200. 

  200. 		$answers = array ();
    201. 

  201. 		foreach ( $this->dbQuery ( 'SELECT id, answer, explanation, is_right FROM answers WHERE question_id=' . $this->id . ' AND is_right="no"' ) as $row ){
    202. 

  202.                     $row['answer'] = stripslashes($row['answer']);
    203. 

  203.                     $row['explanation'] = stripslashes($row['explanation']);
    204. 

  204.                     $answers[] = $row;
    205. 

  205.                         
    206. 

  206. 		}
    207. 

  207. 		return $answers;
    208. 

  208. 	}
    209. 

  209.         public function editAnswer($answerId, $answer, $explanation, $is_right){
    210. 

  210.             $answer = str_replace("\n"," ", $answer);
    211. 

  211.             $explanation = str_replace("\n"," ", $explanation);
    212. 

  212.             $answer = str_replace("<br>"," ", $answer);
    213. 

  213.             $explanation = str_replace("<br>"," ", $explanation);
    214. 

  214.             $this->dbQuery( 'UPDATE answers SET answer=:answer, explanation=:explanation, is_right=:is_right WHERE id=:id ', array ( 
    215. 

  215.                 'answer' => addslashes($answer),
    216. 

  216. 		'explanation' => addslashes($explanation),
    217. 

  217. 		'is_right' => $is_right,
    218. 

  218. 		'id' => $answerId
    219. 

  219.             ) );
    220. 

  220.             $this->guessUpdate();
    221. 

  221.             return $this->getAnswer($answerId);
    222. 

  222. 	}
    223. 

  223. 	public function removeAnswer($answerId){
    224. 

  224. 		$this->dbQuery( "DELETE FROM answers WHERE id=:id", array ( 'id' => $answerId ) );
    225. 

  225. 		$this->guessUpdate();
    226. 

  226. 	}
    227. 

  227.         //get QuestID by answerID
    228. 

  228.         public function getID($answerId){
    229. 

  229. 		return $this->dbGetOne('SELECT question_id FROM answers WHERE id=:id LIMIT 1', array ('id' => $answerId ));
    230. 

  230. 	}
    231. 

  231.         public function addExplanation($answerId, $explanation){
    232. 

  232.             $this->dbQuery("UPDATE answers SET explanation='" . addslashes($explanation) . "' WHERE id=" . $answerId);
    233. 

  233.             $explanation = str_replace("\n"," ", $explanation);
    234. 

  234.             $explanation = str_replace("<br>"," ", $explanation);
    235. 

  235. 	}
    236. 

  236. 	public function getExplanation($answerId){
    237. 

  237. 		$res = $this->dbGetOne( 'SELECT explanation FROM answers WHERE id=:id LIMIT 1', array ('id' => $answerId ) );
    238. 

  238.                 $res = $res;
    239. 

  239.                 return $res;
    240. 

  240. 	}
    241. 

  241. 	public function guessCount() {		
    242. 

  242. 		$count_right = $this->dbGetOne('SELECT count(id) FROM answers WHERE is_right="yes" AND question_id=:id', array('id'=>$this->id));
    243. 

  243. 		$count_false = $this->dbGetOne('SELECT count(id) FROM answers WHERE is_right="no" AND question_id=:id', array('id'=>$this->id));
    244. 

  244. 		if ($count_right > 0 && $count_false > 0){
    245. 

  245. 			$guessing = $count_right/($count_right+$count_false);
    246. 

  246. 		}else $guessing = 0;
    247. 

  247. 		return $guessing;
    248. 

  248. 	}
    249. 

  249. 	public function guessUpdate() {		
    250. 

  250. 		$guessing = $this->guessCount();
    251. 

  251. 		$this->dbQuery("UPDATE questions SET guessing=:guessing WHERE id=:id", array('guessing'=>$guessing,'id'=>$this->id));
    252. 

  252. 		$this->guessing = $guessing;
    253. 

  253. 	}
    254. 

  254. 	public function markDoubtful($user_id, $comment){
    255. 

  255. 		$this->dbQuery("UPDATE questions SET mark='doubtful' WHERE id=" . $this->id);
    256. 

  256. 		$this->dbInsert('doubtful', array('question_id' => $this->id, 'user_id' => $user_id, 'comment' => $comment));
    257. 

  257. 	}	
    258. 

  258. 	public function unMarkDoubtful(){
    259. 

  259. 		$this->dbQuery("UPDATE questions SET mark='accepted' WHERE id=" . $this->id);
    260. 

  260. 		$this->dbQuery('DELETE FROM doubtful WHERE question_id = ' . $this->id);
    261. 

  261. 	}	
    262. 

  262. 	//update count of correct/all_answers
    263. 

  263.         public function editCorrect($correct){            
    264. 

  264.             $this->dbQuery('UPDATE questions SET all_answers = all_answers+1 WHERE id=' . $this->id);
    265. 

  265.             $incorrect = 1-$correct;
    266. 

  266.             $this->dbQuery('UPDATE questions SET incorrect = incorrect+' . $incorrect . ' WHERE id=' . $this->id);
    267. 

  267.             if ($this->dbGetOne('SELECT all_answers FROM questions WHERE id=' . $this->id)>10){
    268. 

  268.                 $this->dbQuery('UPDATE questions SET diff_count=incorrect/all_answers*4+1 WHERE id=' . $this->id);
    269. 

  269.             }
    270. 

  270.         }
    271. 

  271.         public function reAssign($new_slide_id){
    272. 

  272.             $slide = new Slide();
    273. 

  273.             $slide->id = $new_slide_id;
    274. 

  274.             $new_basic_id = $slide->getBasicId();
    275. 

  275.             $this->dbQuery('UPDATE questions SET item_id = '.$new_basic_id.' WHERE id=' . $this->id);
    276. 

  276.         }
    277. 

  277.         
    278. 

  278. }
    279.