wtrmln/modules/plugins/user.php

   1 <?php
   2 /********************************************************************
   3
   4   Watermelon CMS
   5
   6 Copyright 2008-2009 Radosław Pietruszewski
   7
   8 This program is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU General Public License
  10 version 2 as published by the Free Software Foundation.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 ********************************************************************/
  22
  23 class User extends Plugin
  24 {
  25    /*
  26     * private Model_User $User
  27     *
  28     * Instancja klasy Model_User
  29     */
  30    private $User;
  31
  32    /*
  33     * private static bool $LoggedIn
  34     *
  35     * stan użytkownika (zalogowany/niezalogowany)
  36     */
  37
  38    private static $LoggedIn = null;
  39
  40    /*
  41     * private static object[] $users
  42     *
  43     * tablica z danymi userów w postaci obiektu.
  44     *
  45     * $users = array(UID => object(...), UID => object())
  46     */
  47
  48    private static $users;
  49
  50    /*
  51     * public void User()
  52     *
  53     * Konstruktor. Uzupełnia pole $User.
  54     */
  55
  56    public function User()
  57    {
  58       parent::Plugin();
  59
  60       $this->User = $this->load->model('user');
  61    }
  62
  63    /*
  64     * public bool Login(string $user, string $password, bool $autologin)
  65     *
  66     * Loguje użytkownika. Zwraca true, jeśli logowanie wypadło pomyślnie, w
  67     * przeciwnym wypadku zwraca false.
  68     *
  69     * string $user      - Nazwa użytkownika
  70     * string $password  - Hasło użytkownika (w czystej postaci)
  71     * bool   $autologin - Zalogować usera automatycznie przy każdej wizycie?
  72     *                       TRUE - Tak, loguj mnie automatycznie
  73     *                       FALSE - Nie loguj mnie automatycznie
  74     */
  75
  76    public function Login($user, $password, $autologin)
  77    {
  78       // Walidacja wprowadzonych danych
  79
  80       if(empty($user))
  81       {
  82          $errors[] = 'Pole <em>login</em> musi być wypełnione.';
  83       }
  84
  85       if(empty($password))
  86       {
  87          $errors[] = 'Pole <em>hasło</em> musi być wypełnione.';
  88       }
  89
  90       if(isset($errors))
  91       {
  92          setH1('Błąd logowania');
  93
  94          echo $this->load->view('login_loginerrors', array('errors' => $errors));
  95          return false;
  96       }
  97
  98       // sprawdzamy, czy user istnieje
  99
 100       $userdata = $this->User->LoginUserData($user);
 101
 102       if($userdata->num_rows() == 0)
 103       {
 104          setH1('Błąd logowania');
 105
 106          $errors[] = 'Użytkownik <em>' . $user . '</em> nie istnieje.';
 107
 108          echo $this->load->view('login_loginerrors', array('errors' => $errors));
 109          return false;
 110       }
 111
 112       // sprawdzamy poprawność hasła
 113
 114       $userdata = $userdata->to_obj();
 115
 116       if($userdata->password != strHash($password . $userdata->salt, intval($userdata->hashalgo)))
 117       {
 118          setH1('Błąd logowania');
 119
 120          $errors[] = 'Niepoprawne hasło.';
 121
 122          echo $this->load->view('login_loginerrors', array('errors' => $errors));
 123          return false;
 124       }
 125
 126       // generujemy nowy salt i hash i
 127       // zmieniamy hashalgo (jeśli nieaktualne)
 128
 129       $salt = strHash(uniqid(mt_rand(), true));
 130
 131       $salt = substr($salt, 0, 16);
 132
 133       $hash = strHash($password . $salt);
 134
 135       $this->User->updatePassword($user, $hash, $salt, Config::$defaultHashAlgo);
 136
 137       // logujemy :]
 138
 139       $_SESSION['WTRMLN_USER'] = $user;
 140       $_SESSION['WTRMLN_UID']  = $userdata->id;
 141       $_SESSION['WTRMLN_PASS'] = $hash;
 142       $_SESSION['WTRMLN_LASTSEEN'] = time();
 143
 144       // jeszcze informacyjka
 145
 146       //setH1('Logowanie udane');
 147
 148       //echo $this->load->view('login_success');
 149
 150       siteredirect('msg:login_success');
 151
 152       return true;
 153    }
 154
 155    public function Register($user, $password, $password2/*, $email, $email2, $data*/)
 156    {
 157       // Walidacja wprowadzonych danych
 158
 159       if(empty($user))
 160       {
 161          $errors[] = 'Pole <em>login</em> musi być wypełnione.';
 162       }
 163
 164       if(empty($password))
 165       {
 166          $errors[] = 'Pole <em>hasło</em> musi być wypełnione.';
 167       }
 168
 169       if(empty($password2))
 170       {
 171          $errors[] = 'Pole <em>powtórz hasło</em> musi być wypełnione.';
 172       }
 173
 174       if(isset($errors))
 175       {
 176          setH1('Błąd rejestracji');
 177
 178          echo $this->load->view('register_errors', array('errors' => $errors));
 179          return false;
 180       }
 181
 182       // sprawdzamy, czy hasła pasują do siebie
 183
 184       if($password !== $password2)
 185       {
 186          setH1('Błąd rejestracji');
 187
 188          $errors[] = 'Hasła nie pasują do siebie';
 189
 190          echo $this->load->view('register_errors', array('errors' => $errors));
 191          return false;
 192       }
 193
 194       // sprawdzamy, czy user istnieje
 195
 196       $userdata = $this->User->LoginUserData($user);
 197
 198       if($userdata->exists())
 199       {
 200          setH1('Błąd rejestracji');
 201
 202          $errors[] = 'Użytkownik <em>' . $user . '</em> już istnieje.';
 203
 204          echo $this->load->view('register_errors', array('errors' => $errors));
 205          return false;
 206       }
 207
 208       // generujemy salt i hash
 209
 210       $salt = strHash(uniqid(mt_rand(), true));
 211
 212       $salt = substr($salt, 0, 16);
 213
 214       $hash = strHash($password . $salt);
 215
 216       $id = $this->User->register($user, $hash, $salt);
 217
 218       model('pw')->SendPW(1, $id, 'Witaj na stronie!', "Dzięki za rejestrację.\nMożesz już usunąć tą wiadomość.\nPozdrowienia, ekipa strony.", time());
 219
 220       $this->Login($user, $password, 0);
 221
 222       //TODO
 223    }
 224
 225    /*
 226     * public void Logout()
 227     *
 228     * wylogowuje użytkownika (niszczy sesję, nie pokazuje żadnych treści)
 229     */
 230
 231    public function Logout()
 232    {
 233       session_destroy();
 234
 235       self::$LoggedIn = false;
 236    }
 237
 238    /*
 239     * public bool IsLoggedIn()
 240     *
 241     * Sprawdza, czy użytkownik jest zalogowany.
 242     *
 243     * zwraca true, jeśli jeśli użytkownik jest zalogowany,
 244     * w przeciwnym wypadku zwraca false.
 245     */
 246
 247    public function IsLoggedIn()
 248    {
 249       // sprawdzamy, czy już wcześniej funkcja była odpalana
 250
 251       if(self::$LoggedIn !== null)
 252       {
 253          return self::$LoggedIn;
 254       }
 255
 256       // sprawdzamy, czy sesja istnieje
 257
 258       if(!isset($_SESSION['WTRMLN_USER']))
 259       {
 260          self::$LoggedIn = false;
 261          return false;
 262       }
 263
 264       // sprawdzamy, czy user istnieje
 265
 266       $userdata = $this->User->LoginUserData($_SESSION['WTRMLN_USER']);
 267
 268       if(!$userdata->exists())
 269       {
 270          self::$LoggedIn = false;
 271          return false;
 272       }
 273
 274       // sprawdzamy, czy UID pasuje do nicka
 275
 276       $userdata = $userdata->to_obj();
 277
 278       if($userdata->id != $_SESSION['WTRMLN_UID'])
 279       {
 280          self::$LoggedIn = false;
 281          return false;
 282       }
 283
 284       // sprawdzamy poprawność hasła
 285
 286       if($_SESSION['WTRMLN_PASS'] != $userdata->password)
 287       {
 288          self::$LoggedIn = false;
 289          return false;
 290       }
 291
 292       // sprawdzamy kiedy ostatnio był użytkownik
 293       // jeśli przekroczony limit długości sesji (1800 sekund)
 294       // automatycznie wylogowuje
 295
 296       if($_SESSION['WTRMLN_LASTSEEN'] < time() - 1800)
 297       {
 298          $this->Logout();
 299          return false;
 300       }
 301
 302       // aktualizujemy dane
 303
 304       $_SESSION['WTRMLN_LASTSEEN'] = time();
 305
 306       self::$LoggedIn = true;
 307
 308       $this->User->UpdateLastSeen($_SESSION['WTRMLN_UID']);
 309
 310       return true;
 311    }
 312
 313    /*
 314     * public bool IsAdmin()
 315     *
 316     * sprawdza, czy zalogowany użytkownik jest adminem.
 317     * jednocześnie sprawdza, czy w ogóle jest zalogowany.
 318     *
 319     * zwraca true, jeśil zalogowany użytkownik jest adminem,
 320     * a gdy użytkownik nie jest adminem, lub w ogóle nie jest
 321     * zalogowany zwraca false.
 322     */
 323
 324    public function IsAdmin()
 325    {
 326       // sprawdzamy, czy w ogóle jest zalogowany
 327
 328       if(!$this->IsLoggedIn())
 329       {
 330          return false;
 331       }
 332
 333       // sprawdzamy, czy jest w tablicy superusers
 334
 335       $superusers = Config::getSuperusers();
 336
 337       if(array_search($_SESSION['WTRMLN_USER'], $superusers) === false)
 338       {
 339          return false;
 340       }
 341
 342       // sprawdzamy, czy ma odpowiednie uprawnienia w bazie danych
 343
 344       $priviliges = $this->getData($_SESSION['WTRMLN_UID']);
 345
 346       if($priviliges->a_paaccess !== '1')
 347       {
 348          return false;
 349       }
 350
 351       return true;
 352    }
 353
 354    /*
 355     * public static string getNick(uint $uid)
 356     *
 357     * zwraca nick danego użytkownika na podstawie UID
 358     *
 359     * uint $uid - ID użytkownika, którego nick ma zostać zwrócony
 360     */
 361
 362    public static function getNick($uid)
 363    {
 364       $uid = intval($uid);
 365
 366       if(isset(self::$users[$uid]))
 367       {
 368          return self::$users[$uid]->nick;
 369       }
 370
 371       $data = Loader::model('user')->UserData($uid)->to_obj();
 372
 373       self::$users[$uid] = $data;
 374
 375       return $data->nick;
 376    }
 377
 378    /*
 379     * public static string getData(uint $uid)
 380     *
 381     * zwraca dane danego użytkownika na podstawie UID
 382     *
 383     * uint $uid - ID użytkownika, którego dane mają zostać zwrócone
 384     */
 385
 386    public static function getData($uid)
 387    {
 388       $uid = intval($uid);
 389
 390       if(isset(self::$users[$uid]))
 391       {
 392          return self::$users[$uid];
 393       }
 394
 395       $data = Loader::model('user')->UserData($uid)->to_obj();
 396
 397       self::$users[$uid] = $data;
 398
 399       return $data;
 400    }
 401
 402    /*
 403     * public static bool CanI(string $what)
 404     *
 405     * sprawdza, czy aktualnie zalogowany użytkownik ma
 406     * uprawnianie $what. Zwraca true, jeśli tak, w
 407     * przeciwnym wypadku lub gdy nie jest zalogowany
 408     * zwraca false;
 409     */
 410
 411    public static function CanI($what)
 412    {
 413       if(!Controller::$_user->IsLoggedIn())
 414       {
 415          return false;
 416       }
 417
 418       $data = self::getData($_SESSION['WTRMLN_UID']);
 419
 420       if($data->$what == '1')
 421       {
 422          return true;
 423       }
 424       else
 425       {
 426          return false;
 427       }
 428    }
 429 }
 430
 431 ?>