phpDocumentor koliportal
[ class tree: koliportal ] [ index: koliportal ] [ all elements ]

Source for file inc_tabla_func.php

Documentation is available at inc_tabla_func.php

  1. <?php
  2. /**
  3. * @package koliportal
  4. */
  5.  
  6.  
  7.  
  8. /** A szobákba beoszott hallgatók kitörlése
  9. *
  10. * Fejlesztői funkció. Kitörli a room_conn_student tábla tartalmát, s ezzel
  11. * a hallgatókat nem lesznek egyik szobába sem beosztva, valamint a
  12. * hallgatók kívánságait nem használtra állítja, így azok ismét kiértékelhetőek.
  13. * Tesztelés, fejlesztéshez használatos.
  14. */
  15. function debug_clean_tables()
  16. {
  17. global $database;
  18. /* FIXME: csak delevop verzió! */
  19. $sql_d = "DELETE FROM room_conn_student";
  20. mysql_query($sql_d, $database)
  21. or myerr(ERROR_DB, $sql_d);
  22. debug_echo($sql_d, DEBUG_SQL);
  23. $sql_u = "UPDATE wishes SET used = '0'";
  24. mysql_query($sql_u, $database)
  25. or myerr(ERROR_DB, $sql_u);
  26.  
  27. debug_echo($sql_u, DEBUG_SQL);
  28. }
  29.  
  30. /* kivánságok csúcsmátrix létrehozása */
  31. // FIXME: paraméterek? más kell még?
  32. /** Kívánságmátrix létrehozása
  33. *
  34. * Az adatbázis wishes táblája alapján letrehoz egy kétdimenziós tömböt,
  35. * amely a ki-kivel kapcsolatokat tartalmazza. A mátrix [ki, kivel]
  36. * indexű elemének értéke pedig a kívánságlistabeli sorszám lesz
  37. * (wishes.pref).
  38. *
  39. * @param array $sid_list Csak az itt megadott felhasználóazonosítókhoz
  40. * tartozó kívánságokat kérdezi le. A paraméter elhagyása esetén minden felhasználó
  41. * kívánságai bekerülnek a mátrixba.
  42. * @return array A kívánságmátrix, 2 dimenziós táblaként
  43. */
  44. function get_wishes($sid_list = false)
  45. {
  46. global $database;
  47. $wst = array();
  48.  
  49. $ws_q = "SELECT * FROM wishes WHERE used = '0' ";
  50. if (is_array($sid_list) && (count($sid_list) > 0))
  51. {
  52. // FIXME
  53. $ws_q .= " AND ( ";
  54. reset($sid_list);
  55. $i = 0;
  56. while (list(, $sid) = each($sid_list))
  57. {
  58. if ($i++ > 0)
  59. {
  60. $ws_q .= " OR ";
  61. }
  62. $ws_q .= "sid = '$sid'";
  63. }
  64. $ws_q .= " )";
  65. } else {;}
  66. debug_echo($ws_q, DEBUG_SQL);
  67. $ws_res = mysql_query($ws_q, $database)
  68. or myerr(ERROR_DB, $ws_q);
  69.  
  70. while ($ws_arr = mysql_fetch_assoc($ws_res))
  71. {
  72. // [ki][kivel] = hanyadik helyen
  73. $wst[$ws_arr["sid"]][$ws_arr["wsid"]] = $ws_arr["pref"];
  74. }
  75. return $wst;
  76. }
  77.  
  78. /** Hallgatói azonosítók kinyerése egy kivánságmátrixból
  79. *
  80. * A bemeneti kívánságmátrixból kigyűjti az összes hallgatói azonosítót,
  81. * majd egy folytosan indexelt tömb elemeiként visszatér ezekkel.
  82. * Általában a $keys tömbök így állnak elő.
  83. *
  84. * @param array $w Bemeneti kívánságmátrix
  85. * @return array A hallgatók azonosítói egy tömbben
  86. */
  87. function get_students_from_wishlist($w)
  88. {
  89. $s = array();
  90. reset($w);
  91. while (list($wi, $wa) = each($w)) // sorokra bontás
  92. {
  93. $s[$wi] = $wi;
  94. reset($wa);
  95. while (list($wi2, ) = each($wa)) // egy-egy sid kiszedése
  96. {
  97. $s[$wi2] = $wi2;
  98. }
  99. }
  100. $s = array_unique($s);
  101. sort($s, SORT_NUMERIC);
  102. return $s;
  103. }
  104. /** Két szoba összehasonlítása szabad helyek szerint
  105. *
  106. * Segédfüggvény az usort() hoz.
  107. *
  108. * @param array $a Első szoba tömbje
  109. * @param array $b Második szoba tömbje
  110. * @return array Az usort() által várt -1, +1, vagy 0
  111. */
  112. function cmp_rooms_by_space($a, $b)
  113. {
  114. if ($a["freespace"] > $b["freespace"])
  115. {
  116. return 1;
  117. }
  118. if ($a["freespace"] < $b["freespace"])
  119. {
  120. return -1;
  121. }
  122. return 0;
  123. }
  124. /** Szobák összeszámolása szabad hely szerinti bontásban
  125. *
  126. * Egy tömbbe összegyűjti, hogy n szabad hellyel rendelkező szobából
  127. * hány található a listában. Az n lesz a tömb indexe, az n szabad
  128. * hellyel rendelkező szobák száma pedig az indexhez tartozó érték.
  129. *
  130. * @param array $r Szobalista
  131. * @return array Szobák darabszáma szabad hely szerinti bontásban
  132. */
  133. function count_rooms_by_spaces($r)
  134. {
  135. $min = $max = false;
  136. $rets = $s = array();
  137. reset($r);
  138. while (list(, $ra) = each($r))
  139. {
  140. if ((false === $min) || ($min > $ra["freespace"]))
  141. {
  142. $min = $ra["freespace"];
  143. }
  144. if ((false === $max) || ($max < $ra["freespace"]))
  145. {
  146. $max = $ra["freespace"];
  147. }
  148. if (!isset($s[$ra["freespace"]]))
  149. {
  150. $s[$ra["freespace"]] = 0;
  151. }
  152. $s[$ra["freespace"]]++;
  153. }
  154.  
  155. if (count($r) == 0)
  156. {
  157. $rets = array();
  158. } elseif (1 == count($r)) {
  159. reset($r);
  160. list(, $ra) = each($r);
  161. $rets = array($ra["freespace"] => 1);
  162. } else {
  163. /* hogy szép csökkenő sorban legyenek */
  164. for ($i = $max; $i >= $min; $i--)
  165. {
  166. if (isset($s[$i]))
  167. {
  168. $rets[$i] = $s[$i];
  169. }
  170. }
  171. }
  172. return $rets;
  173. }
  174. function get_spaces_min($s)
  175. {
  176. $m = false;
  177. reset($s);
  178. while (list($i, $v) = each($s))
  179. {
  180. if ((false === $m) || ($m > $i))
  181. {
  182. $m = $i;
  183. }
  184. }
  185. return $m;
  186. }
  187. function get_spaces_max($s)
  188. {
  189. $m = false;
  190. reset($s);
  191. while (list($i, $v) = each($s))
  192. {
  193. if ((false === $m) || ($m < $i))
  194. {
  195. $m = $i;
  196. }
  197. }
  198. return $m;
  199. }
  200. /** Felesleges szobák kiszűrése
  201. *
  202. * Pontosan annyi férőhelyet hagy meg a szobalistából, amennyire szükség
  203. * van. Ha nincs annyi összesen, akkor persze kevesebbet.
  204. *
  205. * @param array $rooms Kezdeti szobalista
  206. * @param string $st A szükséges szobatípus
  207. * @param int $num A szükséges férőhelyek száma
  208. * @return array A megmaradt szobalista
  209. */
  210. function strip_extra_rooms($rooms, $st, $num)
  211. {
  212. usort($rooms, "cmp_rooms_by_space");
  213. $spaces = count_rooms_by_spaces($rooms);
  214. $min = get_spaces_min($spaces);
  215. $max = get_spaces_max($spaces);
  216. if (false === $min || false === $max)
  217. {
  218. return $rooms;
  219. }
  220. $sum = 0;
  221. $f = $max;
  222. $used = array();
  223. /* $used[$i] azt jelenti, hogy $i férőhelyes szobából mennyire
  224. van szükség */
  225. //debug_echo(sprintf("min: %d, max: %d, spaces:", $min, $max));
  226. //var_dump($spaces);
  227. for ($i = $max; $i >= $min; $i--)
  228. {
  229. //debug_echo("for space = $i");
  230. // ez egy szoba esetén jól működik?
  231. for ($j = 1; isset($spaces[$i]) && ($j <= $spaces[$i]); $j++)
  232. {
  233. if (!isset($used[$i]))
  234. {
  235. $used[$i] = 0;
  236. }
  237. if ($used[$i] <= $spaces[$i])
  238. {
  239. if ($sum + $i <= $num)
  240. {
  241. $sum += $i;
  242. $used[$i]++;
  243. }
  244. }
  245. //debug_echo(sprintf("j = $j (sum: $sum, used[$i]: %d, spaces[$i]: %d)", $used[$i], $spaces[$i]));
  246. }
  247. }
  248. sort($rooms);
  249. reset($rooms);
  250. $rc = count($rooms);
  251. for ($i = 0; $i < $rc; $i++)
  252. {
  253. $sp = $rooms[$i]["freespace"];
  254. if (isset($used[$sp]) && ($used[$sp] > 0))
  255. {
  256. $used[$sp]--;
  257. } else {
  258. unset($rooms[$i]);
  259. }
  260. }
  261. return $rooms;
  262. }
  263. /** Szobalista lekérdezése
  264. *
  265. * Kinyeri az adatbázisból az adott típusú szobák listáját.
  266. *
  267. * Négyféle szobatípus van:
  268. * - homogén (ST_HOMOGEN): csak egynemű hallgatók kerülhetnek bele, tehát
  269. * csak fiúk, vagy csak lányok
  270. * - heterogén (ST_HETEROGEN): különböző nemű hallgatók is beköltözhetnek
  271. * - lány (ST_FEMALE): csak nőnemű hallgatók vehetik birtokba
  272. * - fiú (ST_MALE): csak fiúk költözhetne be
  273. *
  274. * Keresésnél ha ST_MALE vagy ST_FEMALE szobát keresünk, akkor annak
  275. * megfelelő az ST_HOMOGEN típusú is, hiszen abba is beköltözhetnek csak
  276. * fiúk, vagy csak lányok.
  277. *
  278. * @param int $bid épület azonosítója (buildings.bid)
  279. * @param string $szoba a keresett szobák típusa (ST_* konstansok alapján)
  280. *
  281. * @return array tömbben a szobák azonosítói
  282. */
  283. function get_roomlist($bid, $stype)
  284. {
  285. global $database;
  286.  
  287. if (!is_numeric($bid))
  288. {
  289. myerr(ERROR_CODE, "get_roomlist($bid, $stype): bid isn't numeric");
  290. }
  291. /* FIXME: lehet módosítani kellene a get_roomlist() használó függvényeket,
  292. hogy helyesen működjenek, ha nem csak az ST_HETEROGEN van megkülönböztetve a többitől */
  293.  
  294. switch ($stype)
  295. {
  296. /* a fiú vagy lányszobák lehetnek a HOMOGEN típusúak is, vagy
  297. akár HETEROGEN szobába is rakhatunk csak egyneműeket */
  298. case ST_MALE:
  299. case ST_FEMALE:
  300. $room_q = "SELECT * FROM rooms WHERE bid = '$bid' AND
  301. (rtype = '$stype' OR rtype = 'ST_HOMOGEN' OR rtype = 'ST_HETEROGEN')
  302. ORDER BY rnum";
  303. break;
  304. case ST_HOMOGEN: /* ilyet nem valószínű, h keresne bárki is, de meghagyjuk */
  305. case ST_HETEROGEN:
  306. $room_q = "SELECT * FROM rooms WHERE bid = '$bid' AND rtype = '$stype'
  307. ORDER BY rnum";
  308. break;
  309. case ST_ALL:
  310. /* szobák adatainak lekérdezése... ha esetleg baj van velük, akkor már
  311. itt kiderüljön */
  312. $room_q = "SELECT * FROM rooms WHERE bid = '$bid'";
  313. break;
  314. default:
  315. myerr("Érvénytelen ST_ konstans. get_roomlist()");
  316. break;
  317. }
  318. debug_echo($room_q, DEBUG_SQL);
  319. $room_res = mysql_query($room_q, $database)
  320. or myerr(ERROR_DB, $room_q);
  321.  
  322. $rooms = array();
  323. while ($room_arr = mysql_fetch_assoc($room_res))
  324. {
  325. $rid = $room_arr["roomid"];
  326. $rfs = room_freespace($rid);
  327. if ($rfs > 0)
  328. {
  329. $rooms[$rid] = $room_arr;
  330. $rooms[$rid]["freespace"] = $rfs;
  331. /*
  332. keres jó neki
  333.  
  334. ST_HOMO ST_HOMO
  335. ST_HETERO ST_HETERO
  336. ST_MALE ST_MALE | ((ST_HOMO | ST_HETERO) && (t_MALE | üres))
  337. ST_FEMALE ST_FEMALE | ((ST_HOMO | ST_HETERO) && (t_FEMALE | üres)
  338. */
  339. $real_type = get_room_st($rid);
  340. $rtype = $room_arr["rtype"];
  341. //checkit($room_arr["rtype"], get_room_st($rid))
  342. $type_ok = false;
  343. /* homogén szobát keres, és olyan tényleg a szoba, viszont csak akkor
  344. jó, ha még nem költözött bele senki, mert akkor már ST_MALE vagy ST_FEMALE
  345. kellene h legyen */
  346. // itt akár a szabad helyet is lekérdezhetnénk az ST_ALL helyett
  347. if (($stype == ST_HOMOGEN) && ($rtype == ST_HOMOGEN) && ($real_type == ST_ALL))
  348. {
  349. $type_ok = true;
  350. }
  351. elseif (($stype == ST_HETEROGEN) && ($rtype == ST_HETEROGEN))
  352. {
  353. $type_ok = true;
  354. }
  355. /* női szobát keres, és az is vagy
  356. ((ST_HOMO ill ST_HETERO) és (üres vagy nők vannak benne csak) */
  357. elseif (($stype == ST_MALE) &&
  358. (($rtype == ST_MALE) ||
  359. ((($rtype == ST_HOMOGEN) || ($rtype == ST_HETEROGEN)) &&
  360. (($real_type == ST_MALE) || ($real_type == ST_ALL)))
  361. ))
  362. {
  363. $type_ok = true;
  364. }
  365. /* ugyanaz mint az előző csak ST_FEMALE ST_MALE helyett */
  366. elseif (($stype == ST_FEMALE) &&
  367. (($rtype == ST_FEMALE) ||
  368. ((($rtype == ST_HOMOGEN) || ($rtype == ST_HETEROGEN)) &&
  369. (($real_type == ST_FEMALE) || ($real_type == ST_ALL)))
  370. ))
  371. {
  372. $type_ok = true;
  373. }
  374. /* FIXME: ST_HETEROGEN szobába is kerülhetnek homogénen emberek! */
  375. //$rooms[$rid]["st"] = $st; // FIXME: ez felesleges!
  376. if (false === $type_ok) {
  377. unset($rooms[$rid]);
  378. }
  379. }
  380. }
  381.  
  382. return $rooms;
  383. }
  384. /** Egy szobában lakók nemének meghatározása
  385. *
  386. * Lekérdezi az adatbázisból, hogy kik laknak a megadott szobában: fiúk
  387. * vagy lányok. Ha üres a szoba, akkor ST_ALL -al tér vissza.
  388. *
  389. * Csak a get_roomlist() függvény használja.
  390. *
  391. * @param int $rid szobaazonosító (rooms.roomid)
  392. *
  393. * @return string ST_* konstans
  394. */
  395. function get_room_st($rid)
  396. {
  397. global $database;
  398. $male = $female = false;
  399.  
  400. /*
  401. $r_q = "SELECT * FROM rooms WHERE roomid = '$rid'";
  402. $r_res = mysql_query($r_q, $database)
  403. or myerr(ERROR_DB, $r_q);
  404. if (mysql_num_rows($r_res) === 0)
  405. {
  406. // ez nem nagyon következhetne be
  407. myerr("Mégsincs ilyen szoba? Ez elég gáz.");
  408. } else {
  409. $rarr = mysql_fetch_assoc($r_res)
  410. or myerr("Mégsincs ilyen szoba?");
  411. }
  412. */
  413.  
  414. $sql_q = "SELECT st.sex AS st FROM users AS st, room_conn_student AS ct WHERE
  415. ct.roomid = '$rid' AND st.sid = ct.sid";
  416. /* $sql_q = "SELECT st.sex AS st, rt1.rtype
  417. FROM users AS st, room_conn_student AS ct
  418. LEFT OUTER JOIN rooms AS rt1
  419. ON (ct.roomid = '$rid' AND rt1.roomid = ct.roomid AND st.sid = ct.sid)";*/
  420. $sql_res = mysql_query($sql_q, $database)
  421. or myerr(ERROR_DB, $sql_q);
  422. while ($arr = mysql_fetch_assoc($sql_res))
  423. {
  424. if ($arr["st"] == 'F')
  425. {
  426. $female = true;
  427. } elseif ($arr["st"] == 'M') {
  428. $male = true;
  429. }
  430. }
  431. if ($male && $female)
  432. {
  433. $ret = ST_HETEROGEN;
  434. } elseif ($male && !$female) {
  435. $ret = ST_MALE;
  436. } elseif (!$male && $female) {
  437. $ret = ST_FEMALE;
  438. } else {
  439. $ret = ST_ALL; // ha nincs senki a szobában
  440. }
  441.  
  442. return $ret;
  443. }
  444. /** Szobalistából a minimális szobaméret meghatározása
  445. *
  446. * A megadott szobalista minden szobájára a férőhelyen egy minimumkeresést
  447. * hajt végre. Üres szobalista esetén hibával kilép (ilyen nem fordulhat
  448. * elő, hamarabb kell ellenőrizni.
  449. *
  450. * @param array $r Szobalista
  451. * @return int A minimumkeresés eredménye
  452. */
  453. function get_rooms_spacemin($r)
  454. {
  455. $spacemin = false;
  456. reset($r);
  457. while (list( , $room_arr) = each($r))
  458. {
  459. if ($spacemin === false)
  460. {
  461. $spacemin = $room_arr["space"];
  462. }
  463. elseif ($spacemin > $room_arr["space"])
  464. {
  465. $spacemin = $room_arr["space"];
  466. }
  467. }
  468. if ($spacemin === false)
  469. {
  470. myerr("Üres szobalista!");
  471. }
  472. return $spacemin;
  473. }
  474.  
  475. /** Szobalistából a maximális szobaméret meghatározása
  476. *
  477. * A megadott szobalista minden szobájára a férőhelyen egy maximumkeresést
  478. * hajt végre. Üres szobalista esetén hibával kilép (ilyen nem fordulhat
  479. * elő, hamarabb kell ellenőrizni.
  480. *
  481. * @param array $r Szobalista
  482. * @return int A maxiumkeresés eredménye
  483. */
  484. function get_rooms_spacemax($r)
  485. {
  486. $spacemax = false;
  487. reset($r);
  488. while (list( , $room_arr) = each($r))
  489. {
  490. if ($spacemax === false)
  491. {
  492. $spacemax = $room_arr["space"];
  493. }
  494. elseif ($spacemax < $room_arr["space"])
  495. {
  496. $spacemax = $room_arr["space"];
  497. }
  498. }
  499. if ($spacemax === false)
  500. {
  501. myerr("Üres szobalista!");
  502. }
  503. return $spacemax;
  504. }
  505.  
  506. /** Nem kölcsönös kívánságok eltávolítása
  507. *
  508. * A megkapott kívánságmátrixból eltávolítja a nem kölcsönös kívánságokat.
  509. * Lényegében megnézi, hogy az [i,j] elemhez van-e [j,i]. Ha nincs, akkor
  510. * törli az elemet a tömbből.
  511. *
  512. * @param array $table A kapcsolatokat tartalmazó táblázat
  513. * @param array $key A $table azonosítói egy tömbben
  514. * @return array Csak kölcsönös kívánságokat tartalmazó tömb
  515. */
  516. function drop_single_wishes($table, $keys)
  517. {
  518. sort($keys);
  519. $maxij = count($keys);
  520.  
  521. for ($i = 0; $i < $maxij; $i++)
  522. {
  523. $ki = $keys[$i];
  524. for ($j = 0; $j < $maxij; $j++)
  525. {
  526. $kj = $keys[$j];
  527. /* ha nincs kölcsönös él
  528. [j, i] -hez [i, j], akkor töröljük az
  529. [j, i] -t is
  530. */
  531. if (!isset($table[$ki][$kj]))
  532. {
  533. if (isset($table[$kj]))
  534. {
  535. //debug_echo("unset: $kj, $ki");
  536. unset($table[$kj][$ki]);
  537. }
  538. }
  539. }
  540. }
  541.  
  542. return $table;
  543. }
  544. /** Különböző-e két tömb?
  545. *
  546. * Két tömb különbözőségét vizsgálja. Az array_diff() nem teljesen alkalmas
  547. * erre a feladatra, de használható részeredmények számításához.
  548. *
  549. * @param array $a1 Egyik tömb
  550. * @param array $a2 Másik tömb
  551. */
  552. function array_diffp($a1, $a2)
  553. {
  554. $c = count(array_diff($a1, $a2)) + count(array_diff($a2, $a1));
  555. // felesleges így cicózni, de így struktúrált =)
  556. if ($c == 0)
  557. {
  558. $ret = false; // nem különböznek
  559. }
  560. else
  561. {
  562. $ret = true; // különbözőek
  563. }
  564. return $ret;
  565. }
  566.  
  567. /** Kivánság megkeresése
  568. *
  569. * Megkeresi az $uid felhasználó kivánságlistájában a $pref. helyen szereplő
  570. * hallgató azonosítóját, ha van ilyen a megadott kívánságmátrixban.
  571. *
  572. * @param array $table A kívánságokat tartalmazó táblázat
  573. * @param array $key A $table indexeihez tartozó valódi felhasználói azonosítók (users.sid)
  574. * @param int $uid A felhasználó azonosítója (users.sid)
  575. * @param int $pref A keresett hely a listában
  576. * @return mixed A listában $pref helyen lévő hallgató azonosítója (users.sid), ha
  577. * nincs ilyen, akkor false
  578. */
  579. function find_wish($table, $keys, $uid, $pref)
  580. {
  581. //debug_echo("find_wish(table, keys, $uid, $pref)");
  582. sort($keys);
  583. reset($keys);
  584.  
  585. for ($i = 0; $i < count($keys); $i++)
  586. {
  587. if (isset($table[$uid][$keys[$i]]) && ($table[$uid][$keys[$i]] == $pref))
  588. {
  589. return $keys[$i];
  590. }
  591. }
  592. return false;
  593. }
  594.  
  595. /** Csoportok megjelenítése
  596. *
  597. * Csoportok megjelenítése sorrendezéssel vagy anélkül. Fejlesztői funkció.
  598. *
  599. * @param array $g A csoportokat tartalmazó tömb
  600. * @param bool $sort Legyen-e sorrendezés a megjelenítés előtt
  601. */
  602. function debug_show_groups($g, $sort = true)
  603. {
  604. if (defined("DEBUG_OFF"))
  605. {
  606. return;
  607. }
  608. echo '<pre class="group_list">';
  609. if ($sort)
  610. {
  611. sort($g);
  612. }
  613. for ($i = 0; $i < count($g); $i++)
  614. {
  615. $unames = $vesszo = '';
  616. echo "group[$i]: ";
  617. reset($g[$i]["users"]);
  618. while (list(, $g1user) = each($g[$i]["users"]))
  619. {
  620. echo sprintf("%d (%s); ", $g1user, get_student_st($g1user));
  621. $unames .= sprintf('%s%s', $vesszo, get_student_name($g1user));
  622. $vesszo = ', ';
  623. }
  624. printf("(points: %d) (%s)", $g[$i]["points"], $unames);
  625. echo "\n";
  626. }
  627. echo "</pre>";
  628. }
  629.  
  630. /** Kívánságmátrix megjelenítése
  631. *
  632. * Megjeleníti táblázatos formában egy kivánságmátrixot.
  633. * Fejlesztői funkció.
  634. *
  635. * @param array $table A kívánságokat tartalmazó táblázat
  636. * @param array $key A $table -ben előforduló hallgatói azonosítók sorbarendezve
  637. * @return array A táblázat nem üres elemeinek száma
  638. */
  639. function debug_show_table($alttext, $table, $keys)
  640. {
  641. $num = 0;
  642. $maxij = count($keys);
  643.  
  644. if (defined("DEBUG_OFF") || ($maxij > 25))
  645. {
  646. return;
  647. }
  648.  
  649. echo '<table border="1" class="kivansag_table" title="' . $alttext . '">';
  650. echo "\n";
  651. echo '<tr><th colspan="' . ($maxij + 2) . '">' . $alttext . '</th></tr>';
  652. echo "\n";
  653. echo '<tr><th colspan="2" rowspan="2">z</th><th colspan="' . $maxij . '">kivel</th></tr>';
  654. echo "\n\t<tr>\n";
  655. for ($j = 0; $j < $maxij; $j++)
  656. {
  657. echo "\t\t<th>";
  658. echo $keys[$j];
  659. echo "</th>\n";
  660. }
  661. echo "\t</tr>\n";
  662. for ($i = 0; $i < $maxij; $i++)
  663. {
  664. echo "\t<tr>\n";
  665. if ($i == 0) {
  666. echo "\t\t";
  667. echo '<th rowspan="' . $maxij . '">ki</th>';
  668. echo "\n";
  669. }
  670. echo "\t<th>";
  671. echo $keys[$i];
  672. echo "</th>\n";
  673. for ($j = 0; $j < $maxij; $j++)
  674. {
  675. echo "\t\t<td>";
  676. if (isset($table[$keys[$i]][$keys[$j]]))
  677. {
  678. echo $table[$keys[$i]][$keys[$j]];
  679. $num++;
  680. } else {
  681. echo "";
  682. }
  683. if ($i == $j)
  684. {
  685. echo "-";
  686. }
  687. echo "</td>\n";
  688. }
  689. echo "\t</tr>\n";
  690. }
  691. echo '</table>';
  692. return $num;
  693. }
  694.  
  695. /** Szobák szűrése minimális férőhely alapján
  696. *
  697. * Meghagyja a megadott szobalistából azokat a szobákat, amelyekben legalább
  698. * $minspace ágy található.
  699. *
  700. * @param array $rooms Szobalista (tömbként)
  701. * @param int $minspace A keresett férőhelyek minimuma
  702. * @return array A feltételnek megfelelő szobákt (tömbként)
  703. */
  704. function room_filter_by_minspace($rooms, $minspace)
  705. {
  706. //debug_echo(sprintf("room_filter_by_minspace(%s, %s)", count($rooms) ,$minspace));
  707. $br = array();
  708. reset($rooms);
  709. while (list($i, ) = each($rooms))
  710. {
  711. $free = room_freespace($rooms[$i]["roomid"]);
  712. if ($free >= $minspace)
  713. {
  714. $br[$i] = $rooms[$i];
  715. }
  716. }
  717. return $br;
  718. }
  719.  
  720. /** Szabad helyek számítsa egy szobához
  721. *
  722. * Kiszámítja a megadott szobában a szabad helyek számát.
  723. *
  724. * @param int $roomid A szoba azonosítója
  725. * @return int A szabad ágyak száma
  726. */
  727. function room_freespace($roomid)
  728. {
  729. global $database;
  730. if (!is_numeric($roomid))
  731. {
  732. myerr("room_freespace($roomid)");
  733. }
  734. $mh_q = "SELECT count(*) AS count FROM room_conn_student
  735. WHERE roomid = '$roomid'";
  736. //debug_echo($mh_q, DEBUG_SQL);
  737. $mh_res = mysql_query($mh_q, $database)
  738. or myerr(ERROR_DB, $mh_q);
  739. $mh_arr = mysql_fetch_assoc($mh_res)
  740. or myerr(ERROR_DB, $mh_q);
  741. $sz_q = "SELECT space AS space FROM rooms WHERE roomid = '$roomid'";
  742. //debug_echo($sz_q, DEBUG_SQL);
  743. $sz_res = mysql_query($sz_q, $database)
  744. or myerr(ERROR_DB, $sz_q);
  745. $sz_arr = mysql_fetch_assoc($sz_res)
  746. or myerr(ERROR_DB, $sz_q);
  747. if (!is_numeric($sz_arr["space"]) || !is_numeric($mh_arr["count"]))
  748. {
  749. myerr("room_freespace($roomid)");
  750. }
  751. $marad = $sz_arr["space"] - $mh_arr["count"];
  752. if ($marad < 0)
  753. {
  754. myerr("room_freespace($roomid)");
  755. }
  756. return $marad;
  757. }
  758. /** Elhelyez egy hallgatót egy szobában
  759. *
  760. * A megadott szobát hozzárendeli a megadott hallgatóhoz.
  761. * Technikailag a room_conn_student táblába tölt fel egy rekordot.
  762. * FIXME: itt ellenőrizni kellene mindent
  763. * - ferőhely >= benne lakók száma
  764. * - csak páros szobába kerülhetnek nem azonos neműek
  765. *
  766. * @param int $roomid A szoba azonosítója
  767. * @param int $sid A hallgató azonosítója
  768. */
  769. function szobaba_tesz($roomid, $sid)
  770. {
  771. global $database;
  772. if (!is_numeric($sid))
  773. {
  774. var_dump(debug_backtrace());
  775. die();
  776. }
  777. show_log(sprintf("%s szoba új lakója: %s (roomid: %d, sid: %d)", get_room_name($roomid),
  778. get_student_name($sid), $roomid, $sid));
  779. if (room_freespace($roomid) < 1)
  780. {
  781. myerr("Nincs elég hely a szobában!");
  782. }
  783. //FIXME: csak páros szobába kerülhetnek nem azonos neműek
  784. $sz_i = "INSERT INTO room_conn_student (roomid, sid)
  785. VALUES ('$roomid', '$sid');";
  786. //debug_echo($sz_i, DEBUG_SQL);
  787. $sz_res = mysql_query($sz_i, $database)
  788. or myerr(ERROR_DB, $sz_i);
  789. if (mysql_affected_rows($database) !== 1)
  790. {
  791. myerr(ERROR_DB, $sz_i);
  792. }
  793. }
  794. /** Egy hallgató és a hallgatóra vonatkozó kívánságok érvénytelenítése
  795. *
  796. * A hallgató kivánságainak megjelölése használtként, valamint az összes
  797. * az adott hallgatóra vonatkozó kívánság szintén használtként való
  798. * megjelölése. Erre akkor van szükség, ha a hallgatót már beosztottuk
  799. * valamelyik szobába, mert ilyenkor a további kívánságait nem lehet
  800. * figyelembe venni, mivel egy hallgatót csak egy szobába lehet beosztani.
  801. * Ilyenkor az összes további kívánsága, és az összes olyan kívánság,
  802. * ami az adott hallgatóra vonatkozik érvényét veszti.
  803. *
  804. * Ez technikailag a wishes tábla used attributumának 1-re állítását jelenti.
  805. *
  806. * @param int $student_id A hallgató azonosítója
  807. */
  808. function set_usedwish($student_id)
  809. {
  810. global $database;
  811. //debug_echo("set_usedwish($student_id)", DEBUG_CODE);
  812.  
  813. $sz_u = "UPDATE wishes
  814. SET used = '1'
  815. WHERE sid = '$student_id'
  816. OR wsid = '$student_id'";
  817.  
  818. $sz_res = mysql_query($sz_u, $database)
  819. or myerr(ERROR_DB, $sz_u);
  820. if (mysql_affected_rows($database) === -1)
  821. {
  822. myerr(ERROR_DB, $sz_u);
  823. }
  824. }
  825.  
  826. /** Minden csoportból kimaradt hallgatók összegyűjtése
  827. *
  828. * A függvény összegyűjti azokat a hallgatókat, akik egyik szobába
  829. * sincsenek még beosztva. Ezek tipikusan azok a hallgatók, akik a
  830. * a csoport pontozásánál a hátsó csoportokban szerepeltek,
  831. * és már minden csoporttársukat beosztott valamelyik másik csoporttal.
  832. *
  833. * @param int $bid Az adott épületbe beosztott hallgatók között keres
  834. * @param int $stype A megadott típusú hallgatókat keresi (ST_* konstansok alapján)
  835. * @return array A hallgatók azonosítóit tartalmazó tömb
  836. */
  837. function collect_unassigned_students($bid, $stype)
  838. {
  839. /* FIXME: használhatná az is_assigned_student() függvényt is,
  840. de nem tudom, hogy melyik a gyorsabb */
  841. global $database;
  842. switch ($stype) {
  843. case ST_MALE:
  844. $std_q = "SELECT * FROM users WHERE bid = '$bid' AND ut = 'UT_ASTUDENT' AND sex = 'M'";
  845. break;
  846. case ST_FEMALE:
  847. $std_q = "SELECT * FROM users WHERE bid = '$bid' AND ut = 'UT_ASTUDENT' AND sex = 'F'";
  848. break;
  849. case ST_ALL:
  850. default:
  851. $std_q = "SELECT * FROM users WHERE bid = '$bid' AND ut = 'UT_ASTUDENT'";
  852. break;
  853.  
  854. }
  855. $std_res = mysql_query($std_q, $database)
  856. or myerr(ERROR_DB, $std_q);
  857. $std = array();
  858. while ($std_arr = mysql_fetch_assoc($std_res))
  859. {
  860. $std[] = $std_arr["sid"];
  861. }
  862. $conn_q = "SELECT sid FROM room_conn_student";
  863. $conn_res = mysql_query($conn_q, $database)
  864. or myerr(ERROR_DB, $conn_q);
  865. $assigned_std = array();
  866. while ($conn_arr = mysql_fetch_assoc($conn_res))
  867. {
  868. $assigned_std[] = $conn_arr["sid"];
  869. }
  870. return array_diff($std, $assigned_std);
  871. }
  872.  
  873. /** Szobák összes férőhelyének kiszámítása
  874. *
  875. * A megadott szobalista alapján kiszámolja, hogy hány hallgatót lehet
  876. * elszállásolni összesen.
  877. *
  878. * @param array $roomlist Szobalista
  879. * @return int Összes férőhely
  880. */
  881. function sum_room_space($roomlist)
  882. {
  883. $sum = 0;
  884. reset($roomlist);
  885. while (list( , $room_arr) = each($roomlist))
  886. {
  887. $sum += $spacemin = $room_arr["space"];
  888. }
  889. return $sum;
  890. }
  891.  
  892. /** Férőhelyek és felvett hallgatók épületenkénti ellenőrzése
  893. *
  894. * A függvény ellenőrzi, hogy a megadott épület összes férőhelyében
  895. * elférnek-e az oda felvett hallgatók. Ellenőrzi továbbá, hogy
  896. * ha van az épületben olyan szoba, ahova csak fiúkat, illetve csak
  897. * lányokat lehet beköltöztetni, s ezekből elegendő áll-e az épületbe
  898. * felvett hallgatók rendelkezésére.
  899. *
  900. * @param int $bid Épület-azonosító (buildins.bid)
  901. * @return mixed Siker esetén true, egyébként hibaüzenet (string)
  902. */
  903. function check_spaces($bid, $roomlist)
  904. {
  905. $ret = true;
  906. $students = get_student_list($bid, ST_ALL);
  907. $rooms = get_roomlist($bid, ST_ALL);
  908. $roomspace = sum_room_space($rooms);
  909. if ($roomspace > count($students))
  910. {
  911. $ret = "Az épületbe több hallgató van felvéve, mint a férőhelyek száma!";
  912. return $ret;
  913. }
  914. /*
  915. további ellenőrzések: FIXME:
  916. count get_student_list(ST_FEMALE) << get_roomlist(ST_FEMALE + ST_HETEROGEN + ST_HOMOGEN)
  917. count get_student_list(ST_MALE) << get_roomlist(ST_MALE + ST_HETEROGEN + ST_HOMOGEN)
  918. */
  919. }
  920.  
  921. ?>

Documentation generated on Wed, 18 May 2005 19:24:27 +0200 by phpDocumentor 1.3.0RC3