282 lines
7.6 KiB
PHP
282 lines
7.6 KiB
PHP
<?php
|
|
|
|
namespace App\Models;
|
|
|
|
use Utils;
|
|
use Option;
|
|
use Carbon\Carbon;
|
|
|
|
class User
|
|
{
|
|
public $uid = "";
|
|
public $email = "";
|
|
|
|
private $password = "";
|
|
private $token = "";
|
|
|
|
private $storage_used = null;
|
|
|
|
/**
|
|
* Instance of App\Services\Cipher\{cipher}
|
|
* @var null
|
|
*/
|
|
private $cipher = null;
|
|
|
|
/**
|
|
* Instance of App\Models\UserModel
|
|
* @var null
|
|
*/
|
|
private $model = null;
|
|
|
|
/**
|
|
* Instance of App\Models\Closet
|
|
* @var null
|
|
*/
|
|
public $closet = null;
|
|
|
|
public $is_registered = false;
|
|
public $is_admin = false;
|
|
|
|
/**
|
|
* Pass uid or an array to instantiate a user
|
|
*
|
|
* $info = [
|
|
* 'username' => 'foo',
|
|
* 'email' => 'foo@bar.com'
|
|
* ];
|
|
*
|
|
* @param int $uid
|
|
* @param array $info
|
|
*/
|
|
public function __construct($uid, Array $info = [])
|
|
{
|
|
// Construct user with uid|email|player_name
|
|
if ($uid !== null) {
|
|
$this->uid = $uid;
|
|
$this->model = UserModel::find($uid);
|
|
} else {
|
|
if (isset($info['email'])) {
|
|
$this->email = e($info['email']);
|
|
$this->model = UserModel::where('email', $this->email)->first();
|
|
} elseif (isset($info['username'])) {
|
|
$player = Player::where('player_name', $info['username'])->first();
|
|
$this->uid = $player ? $player['uid'] : 0;
|
|
$this->model = UserModel::find($this->uid);
|
|
} else {
|
|
throw new \InvalidArgumentException('Invalid arguments');
|
|
}
|
|
}
|
|
|
|
$class_name = "App\Services\Cipher\\".config('secure.cipher');
|
|
$this->cipher = new $class_name;
|
|
|
|
if (!is_null($this->model)) {
|
|
$this->is_registered = true;
|
|
$this->uid = $this->model->uid;
|
|
$this->email = $this->model->email;
|
|
$this->password = $this->model->password;
|
|
$this->token = md5($this->email . $this->password . config('secure.salt'));
|
|
$this->closet = new Closet($this->uid);
|
|
$this->is_admin = $this->model->permission == 1 || $this->model->permission == 2;
|
|
}
|
|
}
|
|
|
|
public function checkPasswd($raw_passwd)
|
|
{
|
|
return ($this->cipher->encrypt($raw_passwd, config('secure.salt')) == $this->password);
|
|
}
|
|
|
|
public function changePasswd($new_passwd)
|
|
{
|
|
$this->model->password = $this->cipher->encrypt($new_passwd, config('secure.salt'));
|
|
return $this->model->save();
|
|
}
|
|
|
|
public function getPermission()
|
|
{
|
|
return $this->model->permission;
|
|
}
|
|
|
|
/**
|
|
* Set user permission
|
|
* @param int $permission
|
|
* -1 - banned
|
|
* 0 - normal
|
|
* 1 - admin
|
|
* 2 - super admin
|
|
*/
|
|
public function setPermission($permission)
|
|
{
|
|
return $this->model->update(['permission' => $permission]);
|
|
}
|
|
|
|
public function setEmail($new_email)
|
|
{
|
|
$this->model->email = $new_email;
|
|
return $this->model->save();
|
|
}
|
|
|
|
public function getNickName()
|
|
{
|
|
if (!$this->is_registered) {
|
|
return trans('general.unexistent-user');
|
|
} else {
|
|
return ($this->model->nickname == "") ? $this->email : $this->model->nickname;
|
|
}
|
|
}
|
|
|
|
public function setNickName($new_nickname)
|
|
{
|
|
$this->model->nickname = $new_nickname;
|
|
return $this->model->save();
|
|
}
|
|
|
|
public function getToken($refresh = false)
|
|
{
|
|
if ($this->is_registered && ($this->token === "" || $refresh)) {
|
|
$this->token = md5($this->model->email . $this->model->password . config('secure.salt'));
|
|
}
|
|
|
|
return $this->token;
|
|
}
|
|
|
|
public function getScore()
|
|
{
|
|
return $this->model->score;
|
|
}
|
|
|
|
public function setScore($score, $mode = "set")
|
|
{
|
|
switch ($mode) {
|
|
case 'set':
|
|
$this->model->score = $score;
|
|
break;
|
|
|
|
case 'plus':
|
|
$this->model->score += $score;
|
|
break;
|
|
|
|
case 'minus':
|
|
$this->model->score -= $score;
|
|
break;
|
|
}
|
|
return $this->model->save();
|
|
}
|
|
|
|
public function getStorageUsed()
|
|
{
|
|
if (is_null($this->storage_used)) {
|
|
$this->storage_used = 0;
|
|
// recalculate
|
|
$sql = "SELECT SUM(`size`) AS total_size FROM `{table}` WHERE uploader = {$this->uid}";
|
|
$result = \Database::table('textures')->fetchArray($sql)['total_size'];
|
|
$this->storage_used = $result ?: 0;
|
|
}
|
|
return $this->storage_used;
|
|
}
|
|
|
|
public function checkIn()
|
|
{
|
|
if ($this->canCheckIn()) {
|
|
$sign_score = explode(',', Option::get('sign_score'));
|
|
$aquired_score = rand($sign_score[0], $sign_score[1]);
|
|
$this->setScore($aquired_score, 'plus');
|
|
$this->model->last_sign_at = Utils::getTimeFormatted();
|
|
$this->model->save();
|
|
return $aquired_score;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public function canCheckIn($return_remaining_time = false)
|
|
{
|
|
// convert to timestamp
|
|
$last_sign_at = strtotime($this->getLastSignTime());
|
|
|
|
if (Option::get('sign_after_zero') == "1") {
|
|
$remaining_time = (Carbon::tomorrow()->timestamp - time()) / 3600;
|
|
$can_check_in = $last_sign_at <= Carbon::today()->timestamp;
|
|
} else {
|
|
$remaining_time = ($last_sign_at + Option::get('sign_gap_time') * 3600 - time()) / 3600;
|
|
$can_check_in = $remaining_time <= 0;
|
|
}
|
|
|
|
return $return_remaining_time ? round($remaining_time) : $can_check_in;
|
|
}
|
|
|
|
public function getLastSignTime()
|
|
{
|
|
return $this->model->last_sign_at;
|
|
}
|
|
|
|
/**
|
|
* Register a new user
|
|
* @param string $password
|
|
* @param string $ip
|
|
* @return object, instance of App\Models\User
|
|
*/
|
|
public function register($password, $ip)
|
|
{
|
|
$user = new UserModel();
|
|
|
|
$user->email = $this->email;
|
|
$user->password = $this->cipher->encrypt($password, config('secure.salt'));
|
|
$user->ip = $ip;
|
|
$user->score = Option::get('user_initial_score');
|
|
$user->register_at = Utils::getTimeFormatted();
|
|
$user->last_sign_at = Utils::getTimeFormatted(time() - 86400);
|
|
$user->permission = 0;
|
|
$user->save();
|
|
|
|
$closet = new ClosetModel();
|
|
$closet->uid = $user->uid;
|
|
$closet->textures = "";
|
|
$closet->save();
|
|
|
|
$this->model = $user;
|
|
$this->uid = $user->uid;
|
|
$this->is_registered = true;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getPlayers()
|
|
{
|
|
return Player::where('uid', $this->uid)->get();
|
|
}
|
|
|
|
public function getAvatarId()
|
|
{
|
|
return $this->model->avatar;
|
|
}
|
|
|
|
public function setAvatar($tid)
|
|
{
|
|
$this->model->avatar = $tid;
|
|
return $this->model->save();
|
|
}
|
|
|
|
public function delete()
|
|
{
|
|
Player::where('uid', $this->uid)->delete();
|
|
ClosetModel::where('uid', $this->uid)->delete();
|
|
return $this->model->delete();
|
|
}
|
|
|
|
}
|
|
|
|
class UserModel extends \Illuminate\Database\Eloquent\Model
|
|
{
|
|
public $primaryKey = 'uid';
|
|
protected $table = 'users';
|
|
public $timestamps = false;
|
|
|
|
protected $fillable = ['email', 'nickname', 'permission'];
|
|
|
|
public function scopeLike($query, $field, $value)
|
|
{
|
|
return $query->where($field, 'LIKE', "%$value%");
|
|
}
|
|
}
|