/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/application/models/user.php

  • Committer: Gustav Hatvigsson
  • Date: 2013-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/application/models/user.php
 
1
<?php
 
2
        Class User extends CI_Model {
 
3
                /*
 
4
                 *      Constructor
 
5
                 */
 
6
                function __construct() {
 
7
                        parent::__construct();
 
8
                        
 
9
                        //Load required libraries and drivers
 
10
                        $this->load->database();
 
11
                        $this->load->library('session');
 
12
                }
 
13
 
 
14
 
 
15
                /*
 
16
                 *      This function returns the users password hint (or FALSE if user isn't logged in).
 
17
                 *  RESTRICTED-LEVEL: None
 
18
                 */ 
 
19
                public function getPasswordHint($user) {
 
20
                        //Query-structure
 
21
                        $this->db->select('passwdHint');
 
22
                        $this->db->from('Users');
 
23
                        $this->db->where('userName', $user);
 
24
                        $this->db->limit(1);
 
25
                        
 
26
                        //Execute query
 
27
                        $query = $this->db->get();
 
28
                        $result = $query->result();
 
29
                        
 
30
                        //If a matching DB record is found.
 
31
                        if($result) {
 
32
                                foreach($result as $row) {
 
33
                                        $hint = $row->passwdHint;
 
34
                                        
 
35
                                        //Return hint
 
36
                                        return $hint;
 
37
                                }
 
38
                        }
 
39
                        
 
40
                        //No such user
 
41
                        return FALSE;
 
42
                }
 
43
 
 
44
 
 
45
                /*
 
46
                 *      This function logs the user in (returns FALSE on fail).
 
47
                 *  RESTRICTED-LEVEL: None
 
48
                 */
 
49
                public function login($username, $password) {                   
 
50
                        //Generate a salted hash
 
51
                        $hash = $this->getSaltedHash($password);
 
52
        
 
53
                        //Query-structure
 
54
                        $this->db->select('userName, name, passwd, userType, ssn, activeCourse'); // Tog bort firstLogin här.
 
55
                        $this->db->from('Users');
 
56
                        $this->db->where('userName', $username);
 
57
                        $this->db->where('passwd', $hash);
 
58
                        $this->db->limit(1);
 
59
                        
 
60
                        //Execute query
 
61
                        $query = $this->db->get();
 
62
                        $result = $query->result();
 
63
                        
 
64
                        //If a matching DB record is found.
 
65
                        if($result) {
 
66
                                //Prepare session data
 
67
                                $userDetails = array();
 
68
                                foreach($result as $row) {
 
69
                                        $userDetails = array(
 
70
                                                'username' => $row->userName,
 
71
                                                'name' => $row->name,
 
72
                                                'usertype' => $row->userType,
 
73
                                                'ssn' => $row->ssn,
 
74
                                                'activeCourse' => $row->activeCourse, 
 
75
                                        //      'firstLogin' => $row->firstLogin
 
76
                                        );
 
77
                                }
 
78
                                
 
79
                                //Set session data
 
80
                                $this->session->set_userdata('authenticated', $userDetails);
 
81
                                
 
82
                                //Log attempt as valid
 
83
                                $this->logLogin($username, 1);
 
84
                                
 
85
                                //Return success
 
86
                                return TRUE;
 
87
                        }
 
88
 
 
89
                        //Log attempt as invalid
 
90
                        $this->logLogin($username, 0);
 
91
 
 
92
                        //Return fail
 
93
                        return FALSE;
 
94
                }
 
95
 
 
96
 
 
97
                /*
 
98
                 *      This function logs the user out.
 
99
                 *  RESTRICTED-LEVEL: Self
 
100
                 */
 
101
                public function logout() {
 
102
                        //Unset session data
 
103
                        $this->session->unset_userdata('authenticated');
 
104
                }
 
105
 
 
106
 
 
107
                /*
 
108
                 *      This function changes the users password.
 
109
                 *  RESTRICTED-LEVEL: Self
 
110
                 */
 
111
                public function changePassword($pwdOld, $pwdNew, $pwdHint) {
 
112
                        //Check that a user is logged in.
 
113
                        if($this->isLoggedIn()) {
 
114
                                $user = $this->getUserName();
 
115
                                $oldHash = $this->getSaltedHash($pwdOld);
 
116
                                $newHash = $this->getSaltedHash($pwdNew);
 
117
                                
 
118
                                //Validate input with database
 
119
                                $this->db->select('userName');
 
120
                                $this->db->from('Users');
 
121
                                $this->db->where('userName', $user);
 
122
                                $this->db->where('passwd', $oldHash);
 
123
                                $this->db->limit(1);
 
124
                                $query = $this->db->get();
 
125
                                $result = $query->result();
 
126
                                
 
127
                                //If a matching DB record is found, update database.
 
128
                                if($result) {
 
129
                                        $data = array(
 
130
                                                'passwd' => $newHash,
 
131
                                                'passwdHint' => $pwdHint
 
132
                                        );
 
133
                                        
 
134
                                        $this->db->where('userName', $user);
 
135
                                        $this->db->update('Users', $data);
 
136
                                        
 
137
                                        //Return Success!
 
138
                                        return TRUE;
 
139
                                }
 
140
                        }
 
141
                        
 
142
                        //Return error
 
143
                        return FALSE;
 
144
                }
 
145
 
 
146
 
 
147
                /*
 
148
                 *      This function registers user into the database.
 
149
                 *  RESTRICTED-LEVEL: Teacher
 
150
                 */
 
151
                public function addUser($userName, $name, $ssn, $password, $userType, $pwdHint, $email) {
 
152
                        //Check that a user is logged in and has the right privileges (is teacher)
 
153
                        if($this->isLoggedIn() && $this->getUserType() === 'Teacher') {
 
154
                                //Generate a salted hash
 
155
                                $hash = $this->getSaltedHash($password);
 
156
                                
 
157
                                //Query-structure (All values are escaped automatically by codeigninte, producing safer queries.)
 
158
                                $this->db->set('userName', $userName);
 
159
                                $this->db->set('name', $name);
 
160
                                $this->db->set('ssn', $ssn);
 
161
                                $this->db->set('passwd', $hash);
 
162
                                $this->db->set('userType', $userType);
 
163
                                $this->db->set('passwdHint', $pwdHint);
 
164
                                $this->db->set('email', $email);
 
165
                                $result = $this->db->insert('Users');
 
166
                                
 
167
                                //Check for my-sql error
 
168
                                if($result) {
 
169
                                        //Return success
 
170
                                        return TRUE;
 
171
                                } 
 
172
                        }
 
173
                        
 
174
                        //Return error
 
175
                        return FALSE;
 
176
                }
 
177
 
 
178
                /* 
 
179
                 * Updates the details of a user. Takes a username and an associative array of data with the details to be changed 
 
180
                 */
 
181
                public function updateUser($username, $data) {
 
182
                        $this->db->where("username", $username);
 
183
                        $this->db->update("Users", $data);
 
184
                }
 
185
 
 
186
 
 
187
                /*
 
188
                 *      This function removes users from the database.
 
189
                 *  RESTRICTED-LEVEL: Teacher
 
190
                 */
 
191
                public function removeUser($userName) {
 
192
                        //Check that a user is logged in, has the right privileges (is teacher) and not is the users own username.
 
193
                        if($this->isLoggedIn() && $this->getUserType() === 'Teacher' && $this->getUserName() != $userName) {
 
194
                                //Query-structure
 
195
                                $this->db->where('userName', $userName);
 
196
                                $result = $this->db->delete('Users');
 
197
                                
 
198
                                //Check for my-sql error
 
199
                                if($result) {
 
200
                                        //Return success
 
201
                                        return TRUE;
 
202
                                }
 
203
                        }
 
204
                        
 
205
                        //Return error
 
206
                        return FALSE;
 
207
                }
 
208
 
 
209
 
 
210
                /*
 
211
                 *      This reset the password for the user.
 
212
                 *  RESTRICTED-LEVEL: Teacher
 
213
                 */
 
214
                public function resetUser($userName) {
 
215
                        //Check that a user is logged in, has the right privileges (is teacher) and not is the users own username.
 
216
                        if($this->isLoggedIn() && $this->getUserType() === 'Teacher' && $this->getUserName() != $userName) {
 
217
                                //Check user type
 
218
                                $this->db->select('userName, userType, ssn, email');
 
219
                                $this->db->from('Users');
 
220
                                $this->db->where('userName', $username);
 
221
                                $this->db->limit(1);
 
222
                                $query = $this->db->get();
 
223
                                $result = $query->result();
 
224
                                
 
225
                                //If a matching DB record is found.
 
226
                                if($result) {
 
227
                                        //Prepare new hash depending on user-type
 
228
                                        $newPwdHash = '';
 
229
                                        
 
230
                                        if ($row->userType == 'Student') {
 
231
                                                $newPwdHash = $this->getSaltedHash($row->ssn);
 
232
                                        }
 
233
                                        else if ($row->userType == 'Teacher') {
 
234
                                                //$newPwdHash = $this->getSaltedHash($row->email);
 
235
                                                $newPwdHash = $this->getSaltedHash($row->email);
 
236
                                        }
 
237
                                        
 
238
                                        //Execute reset
 
239
                                        $data = array(
 
240
                                                'passwd' => $newPwdHash,
 
241
                                                'passwdHint' => 'default',
 
242
                                                'firstLogin' => 1
 
243
                                        );
 
244
                                        
 
245
                                        $this->db->where('userName', $userName);
 
246
                                        $this->db->update('Users', $data);
 
247
                                        
 
248
                                        //Return Success!
 
249
                                        return TRUE;
 
250
                                }
 
251
                        }
 
252
                        
 
253
                        //Return error
 
254
                        return FALSE;
 
255
                }
 
256
 
 
257
 
 
258
                /*
 
259
                 *      This parses a user list from ladok and returns an array with users.
 
260
                 *  RESTRICTED-LEVEL: Teacher
 
261
                 */
 
262
                public function parseLadok($string) {
 
263
                        //Check that a user is logged in and has the right privileges (is teacher).
 
264
                        if($this->isLoggedIn() && $this->getUserType() === 'Teacher') {
 
265
                                $userArray = array();
 
266
                                
 
267
                                //Populate array with users from ladok
 
268
                                $ladokUsers = preg_split( '/\r\n|\r|\n/', $string);
 
269
                                
 
270
                                //Trim lines
 
271
                                foreach ($ladokUsers as $key => $value) {
 
272
                                        $ladokUsers[$key] = trim($ladokUsers[$key]);
 
273
                                }
 
274
                                
 
275
                                //Split after last name
 
276
                                foreach ($ladokUsers as $key => $value) {
 
277
                                        $ladokUsers[$key] = explode(',', trim($ladokUsers[$key]));
 
278
                                }
 
279
                                
 
280
                                //Replace whitespaces and tabs with divider.
 
281
                                foreach ($ladokUsers as $key => $value) {
 
282
                                        foreach ($ladokUsers[$key] as $key2 => $value2) {
 
283
                                                $ladokUsers[$key][$key2] = preg_replace('/\s+/', ' ', trim($ladokUsers[$key][$key2]));
 
284
                                        }
 
285
                                }
 
286
                                
 
287
                                //Generate user array
 
288
                                foreach ($ladokUsers as $key => $value) {
 
289
                                        $temp = array(
 
290
                                                'ssn' => substr($ladokUsers[$key][0], 0, 11),
 
291
                                                'lastname' => substr($ladokUsers[$key][0], 12, strlen($ladokUsers[$key][0])),
 
292
                                                'firstname' => substr($ladokUsers[$key][1], 0, stripos($ladokUsers[$key][1], ' ')),
 
293
                                                'email' => substr($ladokUsers[$key][1], (strrpos($ladokUsers[$key][1], ' ') + 1))
 
294
                                        );
 
295
                                        $temp['username'] = substr($temp['email'], 0, (stripos($temp['email'], '@')));
 
296
                                        array_push($userArray, $temp);
 
297
                                }
 
298
                                
 
299
                                //Return parsed user array
 
300
                                return $userArray;
 
301
                        }
 
302
                        
 
303
                        //If not authed
 
304
                        return FALSE;
 
305
                }
 
306
 
 
307
 
 
308
                /*
 
309
                 *      Generates a salted password hash, encrypted with sha1.
 
310
                 *  RESTRICTED-LEVEL: System
 
311
                 */
 
312
                private function getSaltedHash($pwd) {
 
313
                        //Salt = CodeIgniters encryption-key from config
 
314
                        $salt = $this->config->item('encryption_key');
 
315
                        
 
316
                        //Generate SHA1 hash using salt
 
317
                        $hash = sha1($salt.$pwd);
 
318
                        
 
319
                        return $hash;
 
320
                }
 
321
 
 
322
 
 
323
                /*
 
324
                 *      Log the login attempt.
 
325
                 *  RESTRICTED-LEVEL: System
 
326
                 */
 
327
                private function logLogin($userName, $valid) {
 
328
                        $data = array(
 
329
                                'userName' => $userName,
 
330
                                'userAgent' => $this->session->userdata('user_agent'),
 
331
                                'userIP' => $this->session->userdata('ip_address'),
 
332
                                'browserID' => $this->session->userdata('session_id'),
 
333
                                'success' => $valid
 
334
                        );
 
335
                        
 
336
                        $this->db->insert('logUserLoginAttempts', $data);
 
337
                }
 
338
 
 
339
 
 
340
                /*
 
341
                 *      This function return TRUE if the user is logged in and FALSE otherwise.
 
342
                 *  RESTRICTED-LEVEL: System
 
343
                 */
 
344
                public function isLoggedIn() {
 
345
                        if ($this->session->userdata('authenticated')) {
 
346
                                return TRUE;
 
347
                        }
 
348
                        else{
 
349
                                return FALSE;
 
350
                        }
 
351
                }
 
352
 
 
353
 
 
354
                /*
 
355
                 *      This function returns the users type (or FALSE if user isn't logged in).
 
356
                 *  RESTRICTED-LEVEL: System
 
357
                 */
 
358
                public function getUserType() {
 
359
                        if($this->isLoggedIn()) {
 
360
                                $temp = $this->session->userdata('authenticated');
 
361
                                return $temp['usertype'];
 
362
                        }
 
363
                        
 
364
                        return FALSE;
 
365
                }
 
366
 
 
367
 
 
368
                /*
 
369
                 *      This function returns a boolean containing information if it is the first login.
 
370
                 *  RESTRICTED-LEVEL: System
 
371
                 */
 
372
                public function isFirstLogin() {
 
373
                        if($this->isLoggedIn()) {
 
374
                                $temp = $this->session->userdata('authenticated');
 
375
                                if ($temp['firstLogin'] == 1) {
 
376
                                        return TRUE;
 
377
                                }
 
378
                        }
 
379
                        
 
380
                        return FALSE;
 
381
                }
 
382
 
 
383
 
 
384
                /*
 
385
                 *      This function returns the username (or FALSE if user isn't logged in).
 
386
                 *  RESTRICTED-LEVEL: System
 
387
                 */ 
 
388
                public function getUserName() {
 
389
                        if($this->isLoggedIn()) {
 
390
                                $temp = $this->session->userdata('authenticated');
 
391
                                return $temp['username'];
 
392
                        }
 
393
                        
 
394
                        return FALSE;
 
395
                }
 
396
                
 
397
                                /*
 
398
                 *      This function returns the name (or FALSE if user isn't logged in).
 
399
                 *  RESTRICTED-LEVEL: System
 
400
                 */ 
 
401
                public function getName() {
 
402
                        if($this->isLoggedIn()) {
 
403
                                $temp = $this->session->userdata('authenticated');
 
404
                                return $temp['name'];
 
405
                        }
 
406
                        
 
407
                        return FALSE;
 
408
                }
 
409
                
 
410
                                /*
 
411
                 *      This function returns the SSN (or FALSE if user isn't logged in).
 
412
                 *  RESTRICTED-LEVEL: System
 
413
                 */ 
 
414
                public function getSSN() {
 
415
                        if($this->isLoggedIn()) {
 
416
                                $temp = $this->session->userdata('authenticated');
 
417
                                return $temp['ssn'];
 
418
                        }
 
419
                        
 
420
                        return FALSE;
 
421
                }
 
422
                
 
423
                
 
424
                /*
 
425
                * This function fetches the active course info
 
426
                */
 
427
                public function getActiveCourse(){
 
428
                        
 
429
                        if($this->isLoggedIn()) {
 
430
                                $temp = $this->session->userdata('authenticated');
 
431
                                $courseID = $temp['activeCourse'];
 
432
                                $courseName;
 
433
                        
 
434
                                //Query-structure
 
435
                                $this->db->select('name');
 
436
                                $this->db->from('Courses');
 
437
                                $this->db->where('courseID', $courseID);
 
438
                                $this->db->limit(1);
 
439
                                //Execute query
 
440
                                $query = $this->db->get();
 
441
                                $result = $query->result();
 
442
 
 
443
                                foreach($result as $row) {
 
444
                                        $courseName = $row->name;
 
445
                                }
 
446
                                
 
447
                                $data = array(
 
448
                                        'courseID' => $courseID,
 
449
                                        'courseName' => $courseName
 
450
                                );
 
451
                                
 
452
                                return $data;
 
453
                        }
 
454
                        return FALSE;
 
455
                }
 
456
        }
 
457
?>
 
 
b'\\ No newline at end of file'