Dynamická správa rolí a zdrojů?

Myslím že guest i když to je Quest :)

Takže slíbené (moje) best practices:

První věc ACL – pro správu oprávnění a rolí

<?php
class ACL extends Permission
{
        function  __construct()  {
                $this->addRoles(); // add roles
                $this->addResources(); // add all resources

                $this->allow('admin'); // admin muze vse
                $this->allow('guest', array('Dashboard')); // quest muze jen vse na dashboard
        }

        /**
         * Add all Resources
         */
        function addResources() {
                $this->addResource('Dashboard'); // takhle mám pojmenované presentery
                $this->addResource('Config'); // ConfigPresenter.php
                $this->addResource('Client');
        }

        /**
         * Add all roles
         */
        function addRoles()
        {
                $this->addRole('guest'); // moje role
                $this->addRole('admin');
        }
}

?>

ACL.php – umístil jsme do složky presenters (možná by se mu dalo najít i lepší místo) a v config.ini jsem přidal /service.Nette-Security-IAuthorizator = ACL/

Druhá věc boj s uživatelem:

CREATE TABLE  `user` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `email` varchar(255) COLLATE utf8_czech_ci NOT NULL,
  `password` varchar(45) COLLATE utf8_czech_ci NOT NULL,
  `username` varchar(255) COLLATE utf8_czech_ci NOT NULL,
  `real_name` varchar(128) COLLATE utf8_czech_ci NOT NULL,
  `role` varchar(128) COLLATE utf8_czech_ci NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COLLATE=utf8_czech_ci;

to máme tabulku users a model

<?php
class Users extends Object implements IAuthenticator
{
        public function authenticate(array $credentials)
        {
                // input
                $username = strtolower($credentials[self::USERNAME]);
                $password = strtolower($credentials[self::PASSWORD]);

                // search
                if (StrValidate::email($username)) {
                        // autenticate by e-mail
                        $row = dibi::select('*')->from('user')->where('email=%s', $username)->fetch();
                } else {
                        // autenticate by username
                        $row = dibi::select('*')->from('user')->where('username=%s', $username)->fetch();
                }

                // user validate
                if (!$row) {
                        throw new AuthenticationException("Uživatel '$username' nenalezen.", self::IDENTITY_NOT_FOUND);
                }

                // password validate
                if ($row->password !== md5($credentials[self::PASSWORD])) {
                        throw new AuthenticationException("Neplatné heslo.", self::INVALID_CREDENTIAL);
                }
                // unset password
                unset($row->password);

                // tady nacitam taky roli
                return new Identity($row->email, $row->role, $row);

        }

}
?>

Presenter, který se stará o přihlášení

<?php
class AuthPresenter extends Presenter
{
        /** @persistent */
        public $backlink = '';


        public function actionLogin($backlink)
        {
                $form = new AppForm($this, 'form');
                $form->addText('username', 'Uživatelské jméno:')
                        ->addRule(Form::FILLED, 'Zadejte uživatelské jméno, nebo e-mail.');

                $form->addPassword('password', 'Heslo:')
                        ->addRule(Form::FILLED, 'Please provide a password.');

                $form->addSubmit('login', 'Přihlásit');
                $form->onSubmit[] = array($this, 'loginFormSubmitted');

                $form->addProtection('Prosím přihlašte se znovu.');

                $this->template->form = $form;
                $this->template->title = "Přihlásit se";
        }

        public function renderLogout()
        {
                Environment::getUser()->signOut();
                $this->flashMessage('Byl jste úspěšně odhlášen.');
                $this->redirect('Auth:login');
        }

        public function loginFormSubmitted($form)
        {
                try {
                        $user = Environment::getUser();
                        $user->authenticate($form['username']->getValue(), $form['password']->getValue());
                        $this->getApplication()->restoreRequest($this->backlink);
                        $this->redirect('Dashboard:');

                } catch (AuthenticationException $e) {
                        $form->addError($e->getMessage());
                }
        }
}
?>

jo a v config.ini řádek /service.Nette-Security-IAuthenticator = Users/

Nakonec jsem do BasePresenter (po kterém dědí všechny ostatní presentery, kromě AuthPresenter) tohle:

<?php
abstract class BasePresenter extends Presenter
{


        protected function startup()
        {
                // tady kontroluju jestli mam opravneni zobrazit
                if (!Environment::getUser()->isAllowed($this->name, $this->view))
                {
                        //throw new InvalidStateException();
                        $this->redirect('Auth:logout'); // fuj přihlaš se
                } else {
                        echo 'ANO OK mas na to pravo';
                }
        }
}
?>

Editoval Roman Ožana (3. 5. 2009 21:16)

jak je to s „guest“ uctem? tj aby kazdy kdo jen vleze na stranku mel guesti prava? – resit nekde v aplikaci jestli je user NULL nebo ma prava mi prijde „komplikovane“ (proc to nemit v jednom)… ?

v příkladu dáváte ověření identity do funkce startup() v BasePresenteru… jak resite situaci, kdy potrebujete pouzit startup() (napriklad pro nacteni nejake konfigurace) v jinem presentu, ktery od BasePresenteru dedi?

To jsou základy dědičnosti, zkuste si pročíst některý ze článků zabývající se objekty v PHP. Ujasníte si určitě spoustu věcí. Z hlavy mě nenapadá žádný určitý, ale po troše googlení se jistě něco najde.

Já myslím, že zařazení metody do životního cyklu pro kontolu práv je dobrý nápad…ale nemyslím si, že je nutnost tuto metodu deklarovat jako final, jasně, je to lepší…„nevědomky si jí nepřekryju“, ale není to nutnost…rozhodně bych její finalitu nevynucoval…„co kdyby náhodou někde…“;-) Navíc pokud se dobře zvolí název, tak je minimální šance, že jí překryju neúmyslně. Ale pro zavedení rozhodně jsem. Já startup() používám k inicializaci modelů a pokaždé si vzpomenout, že musím volat parent…nic moc. Takže metodu pro práva určitě ano.

Trošku zbytočné

kravco napsal(a):

Jj já vim jak si to myslel, jen sem nechtěl, aby se ona finalita této metody nedostala do jakých si Best practices (viz. nadpis vlákna) a stalo se z toho nějaké dogma. Jinak s tebou souhlasím.

K tomu jestli zbytečné nebo ne…teď tu máme jiné opravdu zbytečné metody prepare atd…ty se nevyužívají, tohle by se imho využívalo, jakmile by si na to lidé zvykli ;-)

romansklenar napsal(a):

Souhlasím s Petrem, událost onStartup je vhodnější než zesložiťovat životní cyklus presenteru. Chtělo by to ale, aby byla přímo ve frameworku.

EDIT: akorát mě nenapadá, kde tu událost nadefinovat… Hned poté, co je aplikaci presenter známý tak ho spouští.

asi jedině v konstructoru (to není nejlepší), nebo takto:

class BasePresenter extends Presenter
{
        public $onStartup = arary(array(__CLASS__,'initialize'));
        static public function initialize($_this)
        {
                $_this->doSomething();
        }
}

To má zase nevýhodu že můze přistupovat jen k public věcem presenteru.

Jako něco takového?

//Presenter
public function startup()
{
        $this->bylVolanParentStartup = true;
}
//Presenter::run()
$this->startup();
if ($this->bylVolanParentStartup !== true)
        throw new WtfException('Co děláš déžo, nezavolal si `parent::startup()`, to se mi ale vůbec nepáčí!!!!');

To by asi viac vecí ulahčilo než zťažilo.