setting type check

src/Auth/Business/LuticateBusiness.php

         $route->post("$prefix/users/login", "${ns}LuticateUsersController", "login");
         $route->post("$prefix/users/logout", "${ns}LuticateUsersController", "logout");
         $route->get("$prefix/users/me", "${ns}LuticateUsersController", "getLightMe");
-        $route->get("$prefix/users/$user_id", "${ns}LuticateUsersController", "getLightById", LuticatePermissions::USER_GET);
+        $route->get("$prefix/users/$user_id", "${ns}LuticateUsersController",
+            "getLightById", LuticatePermissions::USER_GET);
         $route->get("$prefix/users", "${ns}LuticateUsersController", "getAllLight", LuticatePermissions::USER_GET);
-        $route->post("$prefix/users/add", "${ns}LuticateUsersController", "add",
-            array(LuticatePermissions::USER_ADD, LuticatePermissions::USER_GET));
-        $route->post("$prefix/users/$user_id/del", "${ns}LuticateUsersController", "del",
-            array(LuticatePermissions::USER_DEL, LuticatePermissions::USER_GET));
-        $route->post("$prefix/users/$user_id/edit", "${ns}LuticateUsersController", "edit",
-            array(LuticatePermissions::USER_EDIT, LuticatePermissions::USER_GET));
-        $route->post("$prefix/users/me/edit", "${ns}LuticateUsersController", "editMe",
-            LuticatePermissions::USER_EDIT_ME);
-        $route->post("$prefix/users/$user_id/setPassword", "${ns}LuticateUsersController", "setPassword",
-            array(LuticatePermissions::USER_SET_PASSWORD, LuticatePermissions::USER_GET));
+        $route->post("$prefix/users/add", "${ns}LuticateUsersController",
+            "add", array(LuticatePermissions::USER_ADD, LuticatePermissions::USER_GET));
+        $route->post("$prefix/users/$user_id/del", "${ns}LuticateUsersController",
+            "del", array(LuticatePermissions::USER_DEL, LuticatePermissions::USER_GET));
+        $route->post("$prefix/users/$user_id/edit", "${ns}LuticateUsersController",
+            "edit", array(LuticatePermissions::USER_EDIT, LuticatePermissions::USER_GET));
+        $route->post("$prefix/users/me/edit", "${ns}LuticateUsersController",
+            "editMe", LuticatePermissions::USER_EDIT_ME);
+        $route->post("$prefix/users/$user_id/setPassword", "${ns}LuticateUsersController",
+            "setPassword", array(LuticatePermissions::USER_SET_PASSWORD, LuticatePermissions::USER_GET));
         $route->post("$prefix/users/me/setPassword", "${ns}LuticateUsersController", "setPasswordMe",
             LuticatePermissions::USER_SET_PASSWORD_ME);
 
 
-        $route->get("$prefix/groups/$group_id", "${ns}LuticateGroupsController", "getById", LuticatePermissions::GROUP_GET);
+        $route->get("$prefix/groups/$group_id", "${ns}LuticateGroupsController",
+            "getById", LuticatePermissions::GROUP_GET);
         $route->get("$prefix/groups", "${ns}LuticateGroupsController", "getAll", LuticatePermissions::GROUP_GET);
-        $route->post("$prefix/groups/add", "${ns}LuticateGroupsController", "add",
-            array(LuticatePermissions::GROUP_ADD, LuticatePermissions::GROUP_GET));
-        $route->post("$prefix/groups/$group_id/del", "${ns}LuticateGroupsController", "del",
-            array(LuticatePermissions::GROUP_DEL, LuticatePermissions::GROUP_GET));
-        $route->post("$prefix/groups/$group_id/edit", "${ns}LuticateGroupsController", "edit",
-            array(LuticatePermissions::GROUP_EDIT, LuticatePermissions::GROUP_GET));
+        $route->post("$prefix/groups/add", "${ns}LuticateGroupsController",
+            "add", array(LuticatePermissions::GROUP_ADD, LuticatePermissions::GROUP_GET));
+        $route->post("$prefix/groups/$group_id/del", "${ns}LuticateGroupsController",
+            "del", array(LuticatePermissions::GROUP_DEL, LuticatePermissions::GROUP_GET));
+        $route->post("$prefix/groups/$group_id/edit", "${ns}LuticateGroupsController",
+            "edit", array(LuticatePermissions::GROUP_EDIT, LuticatePermissions::GROUP_GET));
 
-        $route->get("$prefix/groups/$group_id/users/", "${ns}LuticateGroupsController", "getUsers",
-            LuticatePermissions::GROUP_GET);
-        $route->post("$prefix/groups/$group_id/users/$user_id/add", "${ns}LuticateGroupsController", "addUser",
-            array(LuticatePermissions::GROUP_USER_ADD, LuticatePermissions::GROUP_GET));
-        $route->post("$prefix/groups/$group_id/users/$user_id/del", "${ns}LuticateGroupsController", "delUser",
-            array(LuticatePermissions::GROUP_USER_DEL, LuticatePermissions::GROUP_GET));
+        $route->get("$prefix/groups/$group_id/users/", "${ns}LuticateGroupsController",
+            "getUsers", LuticatePermissions::GROUP_GET);
+        $route->post("$prefix/groups/$group_id/users/$user_id/add", "${ns}LuticateGroupsController",
+            "addUser", array(LuticatePermissions::GROUP_USER_ADD, LuticatePermissions::GROUP_GET));
+        $route->post("$prefix/groups/$group_id/users/$user_id/del", "${ns}LuticateGroupsController",
+            "delUser", array(LuticatePermissions::GROUP_USER_DEL, LuticatePermissions::GROUP_GET));
 
 
         $route->get("$prefix/permissions/effective/$user_id/$permission_name", "${ns}LuticatePermissionsController",
         $route->get("$prefix/settings/effective/me", "${ns}LuticateSettingsController",
             "getAllEffectiveSettingMe");
 
-        $route->get("$prefix/settings/$setting_name", "${ns}LuticateSettingsController", "get",
-            LuticatePermissions::SETTING_GET);
-        $route->get("$prefix/settings", "${ns}LuticateSettingsController", "getAll",
-            LuticatePermissions::SETTING_GET);
+        $route->get("$prefix/settings/$setting_name", "${ns}LuticateSettingsController",
+            "get", LuticatePermissions::SETTING_GET);
+        $route->get("$prefix/settings", "${ns}LuticateSettingsController",
+            "getAll", LuticatePermissions::SETTING_GET);
         $route->post("$prefix/settings/add", "${ns}LuticateSettingsController",
             "add", array(LuticatePermissions::SETTING_ADD, LuticatePermissions::SETTING_GET));
-        $route->post("$prefix/settings/$setting_name/del", "${ns}LuticateSettingsController", "del",
-            array(LuticatePermissions::SETTING_DEL, LuticatePermissions::SETTING_GET));
+        $route->post("$prefix/settings/$setting_name/del", "${ns}LuticateSettingsController",
+            "del", array(LuticatePermissions::SETTING_DEL, LuticatePermissions::SETTING_GET));
         $route->post("$prefix/settings/$setting_name/edit", "${ns}LuticateSettingsController",
             "edit", array(LuticatePermissions::SETTING_EDIT, LuticatePermissions::SETTING_GET));
+
+        $route->get("$prefix/settings/user/$user_id/$setting_name", "${ns}LuticateSettingsUsersController",
+            "get", LuticatePermissions::SETTING_USER_GET);
+        $route->get("$prefix/settings/user/$user_id", "${ns}LuticateSettingsUsersController",
+            "getAllByUser", LuticatePermissions::SETTING_USER_GET);
+        $route->post("$prefix/settings/user/$user_id/add/$setting_name", "${ns}LuticateSettingsUsersController",
+            "add", array(LuticatePermissions::SETTING_USER_ADD, LuticatePermissions::SETTING_USER_GET));
+        $route->post("$prefix/settings/user/$user_id/$setting_name/del", "${ns}LuticateSettingsUsersController",
+            "del", array(LuticatePermissions::SETTING_USER_DEL, LuticatePermissions::SETTING_USER_GET));
+        $route->post("$prefix/settings/user/$user_id/$setting_name/edit", "${ns}LuticateSettingsUsersController",
+            "edit", array(LuticatePermissions::SETTING_USER_EDIT, LuticatePermissions::SETTING_USER_GET));
     }
 }

src/Auth/Business/LuticateSettingsBusiness.php

 use Luticate\Auth\DataAccess\LuticateSettingsDataAccess;
 use Luticate\Auth\DBO\LuticateSettingsDbo;
 use Luticate\Utils\LuMultipleDbo;
+use Luticate\Utils\LuStringUtils;
 
 class LuticateSettingsBusiness extends LuBusiness {
     protected static function getDataAccess()
      */
     public static function checkSetting($setting)
     {
-        if (is_null($setting->getValue())) {
+        $val = $setting->getValue();
+        $type = $setting->getType();
+        if (is_null($setting->getName())) {
+            self::notFound("Setting Name cannot be null");
+        }
+        if (is_null($val)) {
             self::notFound("Setting Value cannot be null");
         }
-        if (is_null($setting->getType())) {
+        if (is_null($type)) {
             self::notFound("Setting Type cannot be null");
         }
-        else {
-            if (is_array($setting->getValue())) {
-                $setting->setValue(json_encode($setting->getValue()));
-            }
-        }
-        if (is_null($setting->getName())) {
-            self::notFound("Setting Name cannot be null");
-        }
         if (!is_bool($setting->getIsBlocked())) {
             self::notFound("Setting IsBlocked must be boolean");
         }
+        if (!is_bool($setting->getIsAdmin())) {
+            self::notFound("Setting IsAdmin must be boolean");
+        }
+        else {
+            if ($type == "string") {
+                if (!is_string($val)) {
+                    self::badInput("Invalid Value");
+                }
+            }
+            else if ($type == "int") {
+                if (!is_int($val)) {
+                    self::badInput("Invalid Value");
+                }
+            }
+            else if ($type == "float") {
+                if (!is_float($val) && !is_int($val)) {
+                    self::badInput("Invalid Value");
+                }
+            }
+            else if ($type == "bool") {
+                if (!is_bool($val)) {
+                    self::badInput("Invalid Value");
+                }
+            }
+            else if ($type == "object") {
+                if (!is_array($val)) {
+                    self::badInput("Invalid Value");
+                }
+            }
+            else {
+                self::badInput("Unknown Type");
+            }
+            $setting->setValue(json_encode($val));
+        }
     }
 
     public static function checkSettingName($setting_name)
     {
-        $perm = LuticateSettingsDataAccess::getByName($setting_name);
-        if (is_null($perm)) {
+        $setting = LuticateSettingsDataAccess::getByName($setting_name);
+        if (is_null($setting)) {
             self::notFound("Setting not found");
         }
-        return $perm;
+        return $setting;
+    }
+
+    public static function getAll($page = 0, $perPage = 2000000000, $query = "")
+    {
+        return parent::getAll($page, $perPage, $query)->map(function($value)
+        {
+            $value->setValue(json_decode($value->getValue()));
+            return $value;
+        });
     }
 
     public static function getEffectiveSetting($user_id, $setting_name)
     {
-        self::checkSettingName($setting_name);
         $val = LuticateSettingsDataAccess::getEffectiveSetting($user_id, $setting_name);
-        $json = json_decode($val->getSetting());
-        return $json;
+        if (is_null($val->getSetting())) {
+            self::notFound("Setting not found");
+        }
+
+        $setting = LuStringUtils::convertJsonString($val->getSetting());
+        $setting["Value"] = json_decode($setting["Value"]);
+        unset($setting["IsBlocked"]);
+        unset($setting["IsAdmin"]);
+        return $setting;
     }
 
     public static function getAllEffectiveSetting($user_id)
     {
         return LuticateSettingsDataAccess::getAllEffectiveSetting($user_id)->map(function($value)
         {
-            return $value["Settings"];
+            $setting = $value["Settings"];
+            $setting["Value"] = json_decode($setting["Value"]);
+            unset($setting["IsBlocked"]);
+            unset($setting["IsAdmin"]);
+            return $setting;
         });
     }
 
         if (is_null($perm)) {
             self::notFound("Permission not found");
         }
+        $perm->setValue(json_decode($perm->getValue()));
         return $perm;
     }
 
      */
     public static function edit($setting_name, $setting)
     {
-        $setting->setName($setting_name);
+        $set = self::checkSettingName($setting_name);
+        $setting->setName($set->getName());
+        $setting->setType($set->getType());
         self::checkSetting($setting);
-        self::checkSettingName($setting_name);
         LuticateSettingsDataAccess::edit($setting_name, $setting);
         return true;
     }

src/Auth/Business/LuticateSettingsUsersBusiness.php

 use Luticate\Utils\LuBusiness;
 use Luticate\Auth\DataAccess\LuticateSettingsUsersDataAccess;
 use Luticate\Auth\DBO\LuticateSettingsUsersDbo;
+use Luticate\Utils\LuMultipleDbo;
 
 class LuticateSettingsUsersBusiness extends LuBusiness {
     protected static function getDataAccess()
     {
         return new LuticateSettingsUsersDataAccess();
     }
+
+    public static function checkSettingUserName($user_id, $setting_name)
+    {
+        LuticateUsersBusiness::checkUserId($user_id);
+        LuticateSettingsBusiness::checkSettingName($setting_name);
+        return LuticateSettingsUsersDataAccess::getByName($user_id, $setting_name);
+    }
+
+    public static function getAllByUser($user_id, $page = 0, $perPage = 2000000000)
+    {
+        return LuticateSettingsUsersDataAccess::getAllByUser($user_id, $page, $perPage);
+    }
+
+    public static function get($user_id, $setting_name)
+    {
+        return LuticateSettingsUsersDataAccess::getByName($user_id, $setting_name);
+    }
+
+    public static function add($user_id, $setting_name, $setting_value)
+    {
+        $setting = self::checkSettingUserName($user_id, $setting_name);
+        if (!is_null($setting)) {
+            self::badInput("User setting already exists");
+        }
+        $setting = new LuticateSettingsUsersDbo();
+        $setting->setName($setting_name);
+        $setting->setValue($setting_value);
+        $setting->setUserId($user_id);
+        LuticateSettingsUsersDataAccess::add($setting);
+        return true;
+    }
+
+    public static function del($user_id, $setting_name)
+    {
+        self::checkSettingUserName($user_id, $setting_name);
+        LuticateSettingsUsersDataAccess::delete($user_id, $setting_name);
+        return true;
+    }
+
+    public static function edit($user_id, $setting_name, $setting_value)
+    {
+        self::del($user_id, $setting_name);
+        return self::add($user_id, $setting_name, $setting_value);
+    }
 }

src/Auth/Controller/LuticateSettingsUsersController.php

 
 namespace Luticate\Auth\Controller;
 
+use Luticate\Auth\DBO\LuticateUsersDbo;
 use Luticate\Utils\LuController;
 use Luticate\Auth\Business\LuticateSettingsUsersBusiness;
 use Luticate\Auth\DBO\LuticateSettingsUsersDbo;
     {
         return new LuticateSettingsUsersBusiness();
     }
+
+    /**
+     * Get all settings for a user
+     * @param $user_id int The user id
+     * @param int $page The page number, 0 based
+     * @param int $perPage The number of items per page
+     * @return \Luticate\Utils\LuMultipleDbo
+     */
+    public function getAllByUser($user_id, $page = 0, $perPage = 2000000000)
+    {
+        return LuticateSettingsUsersBusiness::getAllByUser($user_id, $page, $perPage);
+    }
+
+    /**
+     * Get a setting for a user
+     * @param $user_id int The user id
+     * @param $setting_name string The setting name
+     * @return \Luticate\Utils\LuDbo
+     */
+    public function get($user_id, $setting_name)
+    {
+        return LuticateSettingsUsersBusiness::get($user_id, $setting_name);
+    }
+
+    /**
+     * Add a setting for a user
+     * @param $user_id int The user id
+     * @param $setting_name string The setting name
+     * @param $setting_value bool The setting value
+     * @return bool
+     */
+    public function add($user_id, $setting_name, $setting_value)
+    {
+        return LuticateSettingsUsersBusiness::add($user_id, $setting_name, $setting_value);
+    }
+
+    /**
+     * Delete a setting for a user
+     * @param $user_id int The user id
+     * @param $setting_name string The setting name
+     * @return bool
+     */
+    public function del($user_id, $setting_name)
+    {
+        return LuticateSettingsUsersBusiness::del($user_id, $setting_name);
+    }
+
+    /**
+     * Delete a setting for the logged user
+     * @param $_user LuticateUsersDbo The logged user
+     * @param $setting_name string The setting name
+     * @return bool
+     */
+    public function reset($_user, $setting_name)
+    {
+        return self::del($_user->getId(), $setting_name);
+    }
+
+    /**
+     * Edit the setting value for a user
+     * @param $user_id int The user id
+     * @param $setting_name string The setting name
+     * @param $setting_value bool The setting value
+     * @return bool
+     */
+    public function edit($user_id, $setting_name, $setting_value)
+    {
+        return LuticateSettingsUsersBusiness::edit($user_id, $setting_name, $setting_value);
+    }
 }

src/Auth/DBO/LuticatePermissions.php

     const SETTING_ADD = "LU_SETTING_ADD";
     const SETTING_EDIT = "LU_SETTING_EDIT";
     const SETTING_DEL = "LU_SETTING_DEL";
+    const SETTING_USER_GET = "LU_SETTING_USER_GET";
+    const SETTING_USER_ADD = "LU_SETTING_USER_ADD";
+    const SETTING_USER_EDIT = "LU_SETTING_USER_EDIT";
+    const SETTING_USER_DEL = "LU_SETTING_USER_DEL";
 }

src/Auth/DBO/LuticateSettingsDbo.php

             "Name" => $this->_name,
             "Type" => $this->_type,
             "Value" => $this->_value,
-            "IsBlocked" => $this->_isBlocked
+            "IsBlocked" => $this->_isBlocked,
+            "IsAdmin" => $this->_isAdmin
         );
     }
 
         if (isset($json["IsBlocked"])) {
             $dbo->setIsBlocked($json["IsBlocked"]);
         }
+        if (isset($json["IsAdmin"])) {
+            $dbo->setIsAdmin($json["IsAdmin"]);
+        }
         return $dbo;
     }
 
         $dbo->setType("sample string");
         $dbo->setValue("sample string");
         $dbo->setIsBlocked(true);
+        $dbo->setIsAdmin(true);
         return $dbo;
     }
 
     {
         $this->_isBlocked = $value;
     }
+
+    /**
+     * @var boolean
+     */
+    protected $_isAdmin;
+    public function getIsAdmin()
+    {
+        return $this->_isAdmin;
+    }
+    public function setIsAdmin($value)
+    {
+        $this->_isAdmin = $value;
+    }
 }

src/Auth/DataAccess/LuticateSettingsDataAccess.php

         if (is_null($perm))
             return;
         $perm->is_blocked = $setting->getIsBlocked();
-        $perm->type = $setting->getType();
+        $perm->is_admin = $setting->getIsAdmin();
         $perm->value = $setting->getValue();
         $perm->save();
     }

src/Auth/DataAccess/LuticateSettingsUsersDataAccess.php

 
 namespace Luticate\Auth\DataAccess;
 
+use Luticate\Auth\DataAccess\Models\LuticateUsers;
 use Luticate\Utils\LuDataAccess;
 use Luticate\Auth\DataAccess\Models\LuticateSettingsUsers;
 use Luticate\Auth\DBO\LuticateSettingsUsersDbo;
     {
         return new LuticateSettingsUsers();
     }
+
+    public static function getModelByName($user_id, $setting_name)
+    {
+        return LuticateSettingsUsers::where("name", "=", $setting_name)->where("user_id", "=", $user_id)->first();
+    }
+
+    public static function getAllByUser($user_id, $page = 0, $perPage = 2000000000)
+    {
+        return self::getMultiple(array(array('user_id', '=', $user_id)), array(array("name", "ASC")), $page, $perPage);
+    }
+
+    public static function getByName($user_id, $setting_name)
+    {
+        $setting = self::getModelByName($user_id, $setting_name);
+        if (is_null($setting)) {
+            return null;
+        }
+        return $setting->toDbo();
+    }
+
+    public static function delete($user_id, $setting_name)
+    {
+        LuticateUsers::find($user_id)->settings()->detach($setting_name);
+    }
 }

src/Auth/DataAccess/Models/LuticateSettingsModel.php

         $dbo->setType($this->type);
         $dbo->setValue($this->value);
         $dbo->setIsBlocked($this->is_blocked);
+        $dbo->setIsAdmin($this->is_admin);
 
         return $dbo;
     }
         $model->type = $dbo->getType();
         $model->value = $dbo->getValue();
         $model->is_blocked = $dbo->getIsBlocked();
+        $model->is_admin = $dbo->getIsAdmin();
 
         return $model;
     }

src/Auth/DataAccess/Models/LuticateSettingsUsers.php

 
 class LuticateSettingsUsers extends LuticateSettingsUsersModel
 {
+    protected $primaryKey = "name";
 }

src/Auth/DataAccess/Models/LuticateUsers.php

     {
         return $this->belongsToMany('Luticate\Auth\DataAccess\Models\LuticatePermissions', "luticate_permissions_users", "user_id", "name");
     }
+
+    public function settings()
+    {
+        return $this->belongsToMany('Luticate\Auth\DataAccess\Models\LuticateSettings', "luticate_settings_users", "user_id", "name");
+    }
 }