userSettingsManager

Dieser Bereich dient dazu, eure Tricks und Erweiterungen vorzustellen, damit diese auch andere Anwender nutzen können. // This area can be used to publish your tricks and extensions to the APF to be used by other developers.
Antworten
Benutzeravatar
Screeze
Beiträge: 1920
Registriert: 05.08.2009, 09:49:04
Kontaktdaten:

userSettingsManager

Beitrag von Screeze » 22.09.2009, 15:08:16

So, wieder eine Erweiterung von mir, ich glaub die 5. :D
Anhand dessen was wir im andern Thread besprochen haben, hab ich mal einen SettingsManager gebastelt. Dieser handelt unabhängig vom userSessionsManager; anders als ichs zuletzt geplant hatte.

Der userSettingsManager benötigt eine datenbank tabelle mit folgendem Aufbau:

Code: Alles auswählen

CREATE TABLE IF NOT EXISTS `user_settings` (
  `UserID` int(11) NOT NULL,
  `key` varchar(255) NOT NULL,
  `value` varchar(255) NOT NULL,
  KEY `UserID` (`UserID`,`key`),
  KEY `UserID_2` (`UserID`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
(sind die Indizes so richtig gesetzt? Damit kenne ich mich nicht so gut aus, aber es werden ja immer entweder nach userId und key, oder nur nach userID gesucht, ich denke so stimmts?)

Außerdem die userSettingsManager klasse:
.../mytools/userSettingsManager/biz/userSettingsManager.php

Code: Alles auswählen

<?php
/**
 * Manages userspecific settings. Use as Sessionsingleton.
 *
 * @namespace mytools::userSettingsManager::biz
 * @author Ralf Schubert
 * @version 0.1, 22.09.2009<br>
 */
class userSettingsManager extends coreObject{

    protected $__userSettings = null;
    protected $__userID = null;

    /**
     * Initialize userSettingsManager
     *
     * @param int $userID the users ID
     */
    public function init($userID){
        if($this->__userID === null)
            $this->__userID = (int) $userID;
        if($this->__userSettings === null)
            $this->__userSettings = $this->__loadAllSettings();
    }

    /**
     * Recieve a single setting.
     *
     * @param string $key The settings key.
     * @param bool $force Optional. If set to true, key will be loaded from database,
     * even if it's already in cache.
     *
     * @return string The settings value.
     */
    public function getValue($key, $force = false){
        if(
            !isset($this->__userSettings[$key]) OR
            $force === true OR
            $this->__userSettings[$key] === null
        )
        {
            $this->__userSettings[$key] = $this->__loadSingleSetting($key);
        }
        
        return $this->__userSettings[$key];
    }
    
    /**
     * Saves a single setting into database.
     * 
     * @param string $key The settings key
     * @param string $value The settings value
     */
    public function saveValue($key, $value){
        $SQL = &$this->__getServiceObject('core::database','MySQLHandler');

        // Check if key already exists for this user
        $select = 'SELECT
                    `value`
                  FROM
                    `user_settings`
                  WHERE
                    `UserID` = "' . $this->__userID . '" AND
                    `key` = "' . $key . '"';

        $result = $SQL->executeTextStatement($select);
        $data = $SQL->fetchData($result);
        
        // Secure inputs
        $value = $SQL->escapeValue($value);

        if($data !== false){
            // Key already exists for this user, just UPDATE it

            $update = 'UPDATE
                        `user_settings`
                      SET
                        `value` = "' . $value . '"
                      WHERE
                        `UserID` = "' . $this->__userID . '" AND
                        `key` = "' . $key . '"';
            $SQL->executeTextStatement($update);
            
            unset($update);
        }
        else {
            // Key does not exist, INSERT it

            $insert = 'INSERT
                        INTO
                            `user_settings`
                          (
                            `UserID`,
                            `key`,
                            `value`
                          )
                        VALUES
                          (
                            "' . $this->__userID . '",
                            "' . $key . '",
                            "' . $value . '"
                          )';
            $SQL->executeTextStatement($insert);
        }
        unset($data);

        // Copy to Cache
        $this->__userSettings[$key] = $value;
    }

    /**
     * Deletes a single setting from database.
     * @param string $key The settings key.
     */
    public function deleteSingleSetting($key){
        $SQL = &$this->__getServiceObject('core::database','MySQLHandler');

        $delete = 'DELETE
                      FROM `user_settings`
                  WHERE
                      `UserID` = "' . $this->__userID . '" AND
                      `key` = "' . $key . '"
                  LIMIT 1';
        $SQL->executeTextStatement($delete);
        unset($this->__userSettings[$key]);
    }

    /**
     * Deletes all settings of this user from database.
     */
    public function deleteUserSettings(){
        $SQL = &$this->__getServiceObject('core::database','MySQLHandler');

        $delete = 'DELETE
                      FROM `user_settings`
                  WHERE
                      `UserID` = "' . $this->__userID . '"';
        $SQL->executeTextStatement($delete);
        $this->__userSettings = null;
    }

    /**
     * Logout for user.
     */
    public function logout(){
        $this->__userID = null;
        $this->__userSettings = null;
    }

    /**
     * Loads a single setting from database.
     * 
     * @param string $key The settings key
     * 
     * @return string The Settings value
     */
    protected function __loadSingleSetting($key){
        $SQL = &$this->__getServiceObject('core::database','MySQLHandler');

        $select = 'SELECT
                    `value`
                  FROM
                    `user_settings`
                  WHERE
                    `UserID` = "' . $this->__userID . '" AND
                    `key` = "' . $key . '"
                  LIMIT 1';
        $result = $SQL->executeTextStatement($select);
        $data = $SQL->fetchData($result);
        
        return $data['value'];
    }

    /**
     * Loads all settings from a single user from database.
     *
     * @return array An assoziative array with the settings
     */
    protected function __loadAllSettings(){
        $SQL = &$this->__getServiceObject('core::database','MySQLHandler');

        $select = 'SELECT
                    `key`,
                    `value`
                  FROM
                    `user_settings`
                  WHERE
                    `userID` = "' . $this->__userID . '"';

        $result = $SQL->executeTextStatement($select);

        $return = array();
        while($data = $SQL->fetchData($result)){
            $return[$data['key']] = $data['value'];
        }
        
        unset($SQL, $select, $result);
        return $return;
    }

    public function __sleep(){
        return array('__userSettings', '__userID');
    }

}
?>

Somit wären die Grundlagen geschaffen.
Der UserSettingsManager wird per

Code: Alles auswählen

$userSettingsManager = &$this->__getAndInitServiceObject('mytools::userSettingsManager::biz','userSettingsManager', $user->getProperty('UserID'), 'SESSIONSINGLETON');
initialisiert (wichtig: die ...AndInit... Methode verwenden!), wobei der 3. Parameter (bei mir: $user->getProperty('UserID')) die ID des aktuellen Users sein muss. ich hab mir diese direkt aus dem User objekt geholt.

Die Einstellungen sind immer als key => value paar vorhanden.

Beim instanzieren werden automatisch alle settings des users in einen internen cache geladen.
Beim abrufen einer Setting wird geprüft ob der aktuelle key schon im cache vorhanden ist, und notfalls nachgeladen.

Es stehen folgende Methoden zur verfügung:
getValue($key[, $force]): Läd das Value zu einem bestimmten Key. (als string) Sollte $force auf true gesetzt werden, wird der key IMMER aus der Datenbank geladen, und nicht aus dem cache.
saveValue($key, $value): Speichert eine neue oder UPDATED eine schon vorhandene Einstellung in der Datenbank, und kopiert sie in den cache.
deleteSingleSetting($key): Löscht ein einzelnes key->value paket aus der Datenbank und dem cache.
deleteUserSettings(): Löscht alle Settings des aktuellen Benutzers aus der Datenbank und dem cache.
logout(): Löscht den Cache und den Speicher der userId.

Ich werde dennoch im userSESSIONmanager eine optionale supportfunktion für den SettingsManager bereitstellen, damit man sich nicht selbst um die aktualisierung der UserId ect. kümmern muss.

Kommentare? vorschläge? Immer her damit ;)

Screeze

P.s.: wann kommen mal erweiterungen von euch? :D

Antworten

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast