CREATE TABLE `blog` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `topic` varchar(255) DEFAULT NULL COMMENT 'ชื่อเรื่อง',
  `detail` varchar(255) DEFAULT NULL COMMENT 'รายละเอียด',
  `tag` varchar(15) DEFAULT NULL COMMENT 'แท็ก',
  `created_by` int(11) DEFAULT NULL,
  `updated_by` int(11) DEFAULT NULL,
  `created_at` int(11) DEFAULT NULL,
  `updated_at` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8

$menuItems = [
              ['label' => 'Home', 'url' => ['/site/index']],
              ['label' => 'Blog', 'url' => ['/blog/index']],
              ['label' => 'About', 'url' => ['/site/about']],
              ['label' => 'Contact', 'url' => ['/site/contact']],
          ];

 <?php

 class User extends ActiveRecord implements IdentityInterface
{
    const STATUS_DELETED = 0;
    const STATUS_ACTIVE = 10;

    const ROLE_USER = 10;
    const ROLE_MODERATOR = 20;
    const ROLE_ADMIN = 30;
    // ...
}

 <?php

namespace common\components;
use common\models\User;

class AccessRule extends \yii\filters\AccessRule{

    /**
     * @inheritdoc
     */
    protected function matchRole($user){

        if(empty($this->roles)){
            return true;
        }
        foreach ($this->roles as $role){

            if($role == '?' && $user->getIsGuest()){
                    return true;
            }
            elseif($role == User::ROLE_USER && !$user->getIsGuest()){
                    return true;
            }
            elseif(!$user->getIsGuest() && $role == $user->identity->role){
                return true;
            }
        }
        return false;
    }
}

 <?php

namespace frontend\controllers;

use Yii;
use common\models\Blog;
use frontend\models\BlogSearch;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
use yii\filters\VerbFilter;

/**
 * BlogController implements the CRUD actions for Blog model.
 */
class BlogController extends Controller
{
    public function behaviors()
    {
        return [
            'verbs' => [
                'class' => VerbFilter::className(),
                'actions' => [
                    'delete' => ['post'],
                ],
            ],
        ];
    }

    // ...
}

<?php

namespace frontend\controllers;

use Yii;
use common\models\Blog;
use common\models\User;
use frontend\models\BlogSearch;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
use yii\filters\VerbFilter;
use yii\filters\AccessControl;
use common\components\AccessRule;

/**
 * BlogController implements the CRUD actions for Blog model.
 */
class BlogController extends Controller
{
public function behaviors(){
        return [
            'verbs' => [
                'class' => VerbFilter::className(),
                'actions' => [
                    'delete' => ['post'],
                ],
            ],
            'access'=>[
                'class'=>AccessControl::className(),
                'only'=> ['index','create','update','view','delete'],
                'ruleConfig'=>[
                    'class'=>AccessRule::className()
                ],
                'rules'=>[
                    [
                        'actions'=>['index','create','view'],
                        'allow'=> true,
                        'roles'=>[
                            User::ROLE_USER,
                            User::ROLE_MODERATOR,
                            User::ROLE_ADMIN

                        ]
                    ],
                    [
                        'actions'=>['update'],
                        'allow'=> true,
                        'roles'=>[
                            User::ROLE_MODERATOR,
                            User::ROLE_ADMIN
                        ]
                    ],
                    [
                        'actions'=>['delete'],
                        'allow'=> true,
                        'roles'=>[User::ROLE_ADMIN]
                    ]
                ]
            ]
        ];
    }
  // ...
}

<?php
namespace frontend\models;

use common\models\User;
use yii\base\Model;
use Yii;
/**
 * Signup form
 */
class SignupForm extends Model
{
// ...
    public function signup()
    {
        if ($this->validate()) {
            $user = new User();
            $user->username = $this->username;
            $user->email = $this->email;
            $user->setPassword($this->password);
            $user->generateAuthKey();
            $user->role = User::ROLE_USER; // <<--------
            if ($user->save()) {
                return $user;
            }
        }

        return null;
    }

// ...

}

public function rules()
{
    return [
        ['status', 'default', 'value' => self::STATUS_ACTIVE],
        ['status', 'in', 'range' => [self::STATUS_ACTIVE, self::STATUS_DELETED]],

        ['role','integer'],
        ['role', 'default', 'value' => self::ROLE_USER],

        ['username', 'filter', 'filter' => 'trim'],
        ['username', 'required'],
        ['username', 'unique', 'targetClass' => '\common\models\User', 'message' => 'This username has already been taken.'],
        ['username', 'string', 'min' => 2, 'max' => 255],

        ['email', 'filter', 'filter' => 'trim'],
        ['email', 'required'],
        ['email', 'email'],
        ['email', 'unique', 'targetClass' => '\common\models\User', 'message' => 'This email address has already been taken.'],

        ['password', 'required'],
        ['password', 'string', 'min' => 6],
    ];
}

public static function getItemsAlias($id){
    $items =  [
        'status'=>[
            self::STATUS_ACTIVE => 'Active',
            self::STATUS_DELETED => 'Deleted'
        ],
        'role' => [
            self::ROLE_ADMIN => 'Administrator',
            self::ROLE_MODERATOR => 'Moderator',
            self::ROLE_USER => 'User'
        ]
    ];
    return array_key_exists($id, $items) ? $items[$id] : [];
}

public function getItemStatus(){
    return self::getItemsAlias('status');
}

public function getStatusName(){
    $items =  $this->getItemStatus();
    return array_key_exists($this->status, $items) ? $items[$this->status] : null;
}

public function getItemRole(){
    return self::getItemsAlias('role');
}

public function getRoleName(){
    $items =  $this->getItemRole();
    return array_key_exists($this->role, $items) ? $items[$this->role] : null;
}

<?= $form->field($model, 'status')->inline()->radioList($model->getItemStatus()) ?>
<?= $form->field($model, 'status')->inline()->dropdownList($model->getItemStatus()) ?>

<?php
use common\models\User;
?>
<?= GridView::widget([
        'dataProvider' => $dataProvider,
        'filterModel' => $searchModel,
        'columns' => [
            'statusName',
            [
              'attribute'=>'status',
              'filter'=>User::getItemsAlias('status'),
              'value'=>function($model){
                return $model->statusName;
              }
            ],
            'roleName',
            [
              'attribute'=>'role',
              'filter'=>User::getItemsAlias('role'),
              'value'=>function($model){
                return $model->roleName;
              }
            ],
        ],
    ]); ?>

<?= DetailView::widget([
    'model' => $model,
    'attributes' => [
        'statusName',
        'roleName',
    ],
]) ?>

<?php
namespace common\models;

use Yii;
use yii\base\NotSupportedException;
use yii\behaviors\TimestampBehavior;
use yii\db\ActiveRecord;
use yii\web\IdentityInterface;

/**
 * User model
 *
 * @property integer $id
 * @property string $username
 * @property string $password_hash
 * @property string $password_reset_token
 * @property string $email
 * @property string $auth_key
 * @property integer $status
 * @property integer $created_at
 * @property integer $updated_at
 * @property string $password write-only password
 */
class User extends ActiveRecord implements IdentityInterface
{
    const STATUS_DELETED = 0;
    const STATUS_ACTIVE = 10;

    const ROLE_USER = 10;
    const ROLE_MODERATOR = 20;
    const ROLE_ADMIN = 30;

    public $password;

    /**
     * @inheritdoc
     */
    public static function tableName()
    {
        return '';
    }

    /**
     * @inheritdoc
     */
    public function behaviors()
    {
        return [
            TimestampBehavior::className(),
        ];
    }

    /**
     * @inheritdoc
     */
    public function rules()
    {
        return [
            ['status', 'default', 'value' => self::STATUS_ACTIVE],
            ['status', 'in', 'range' => [self::STATUS_ACTIVE, self::STATUS_DELETED]],

            ['role','integer'],
            ['role', 'default', 'value' => self::ROLE_USER],

            ['username', 'filter', 'filter' => 'trim'],
            ['username', 'required'],
            ['username', 'unique', 'targetClass' => '\common\models\User', 'message' => 'This username has already been taken.'],
            ['username', 'string', 'min' => 2, 'max' => 255],

            ['email', 'filter', 'filter' => 'trim'],
            ['email', 'required'],
            ['email', 'email'],
            ['email', 'unique', 'targetClass' => '\common\models\User', 'message' => 'This email address has already been taken.'],

            ['password', 'required'],
            ['password', 'string', 'min' => 6],
        ];
    }

    /**
     * @inheritdoc
     */
    public static function findIdentity($id)
    {
        return static::findOne(['id' => $id, 'status' => self::STATUS_ACTIVE]);
    }

    /**
     * @inheritdoc
     */
    public static function findIdentityByAccessToken($token, $type = null)
    {
        throw new NotSupportedException('"findIdentityByAccessToken" is not implemented.');
    }

    /**
     * Finds user by username
     *
     * @param string $username
     * @return static|null
     */
    public static function findByUsername($username)
    {
        return static::findOne(['username' => $username, 'status' => self::STATUS_ACTIVE]);
    }

    /**
     * Finds user by password reset token
     *
     * @param string $token password reset token
     * @return static|null
     */
    public static function findByPasswordResetToken($token)
    {
        if (!static::isPasswordResetTokenValid($token)) {
            return null;
        }

        return static::findOne([
            'password_reset_token' => $token,
            'status' => self::STATUS_ACTIVE,
        ]);
    }

    /**
     * Finds out if password reset token is valid
     *
     * @param string $token password reset token
     * @return boolean
     */
    public static function isPasswordResetTokenValid($token)
    {
        if (empty($token)) {
            return false;
        }
        $expire = Yii::$app->params['user.passwordResetTokenExpire'];
        $parts = explode('_', $token);
        $timestamp = (int) end($parts);
        return $timestamp + $expire >= time();
    }

    /**
     * @inheritdoc
     */
    public function getId()
    {
        return $this->getPrimaryKey();
    }

    /**
     * @inheritdoc
     */
    public function getAuthKey()
    {
        return $this->auth_key;
    }

    /**
     * @inheritdoc
     */
    public function validateAuthKey($authKey)
    {
        return $this->getAuthKey() === $authKey;
    }

    /**
     * Validates password
     *
     * @param string $password password to validate
     * @return boolean if password provided is valid for current user
     */
    public function validatePassword($password)
    {
        return Yii::$app->security->validatePassword($password, $this->password_hash);
    }

    /**
     * Generates password hash from password and sets it to the model
     *
     * @param string $password
     */
    public function setPassword($password)
    {
        $this->password_hash = Yii::$app->security->generatePasswordHash($password);
    }

    /**
     * Generates "remember me" authentication key
     */
    public function generateAuthKey()
    {
        $this->auth_key = Yii::$app->security->generateRandomString();
    }

    /**
     * Generates new password reset token
     */
    public function generatePasswordResetToken()
    {
        $this->password_reset_token = Yii::$app->security->generateRandomString() . '_' . time();
    }

    /**
     * Removes password reset token
     */
    public function removePasswordResetToken()
    {
        $this->password_reset_token = null;
    }


    public static function getItemsAlias($id){
        $items =  [
            'status'=>[
                self::STATUS_ACTIVE => 'Active',
                self::STATUS_DELETED => 'Deleted'
            ],
            'role' => [
                self::ROLE_ADMIN => 'Administrator',
                self::ROLE_MODERATOR => 'Moderator',
                self::ROLE_USER => 'User'
            ]
        ];
        return array_key_exists($id, $items) ? $items[$id] : [];
    }

    public function getItemStatus(){
        return self::getItemsAlias('status');
    }

    public function getStatusName(){
        $items =  $this->getItemStatus();
        return array_key_exists($this->status, $items) ? $items[$this->status] : null;
    }

    public function getItemRole(){
        return self::getItemsAlias('role');
    }

    public function getRoleName(){
        $items =  $this->getItemRole();
        return array_key_exists($this->role, $items) ? $items[$this->role] : null;
    }
}

$menuItems = [
              ['label' => 'Home', 'url' => ['/site/index']],
              ['label' => 'User Management', 'url' => ['/user/index']],
          ];

<?php
// ...

public function behaviors()
{
    return [
        'verbs' => [
            'class' => VerbFilter::className(),
            'actions' => [
                'delete' => ['post'],
            ],
        ],
        'access'=>[
            'class'=> AccessControl::className(),
            'only' =>['index','view','create','update','delete'],
            'ruleConfig'=> [
                'class' => AccessRule::className()
            ],
            'rules'=>[
                [
                   'roles' => [
                        User::ROLE_ADMIN
                    ],
                   'allow' => true,
                ]
            ]
        ]
    ];
}

<?php
// ...

/**
 * Creates a new User model.
 * If creation is successful, the browser will be redirected to the 'view' page.
 * @return mixed
 */
public function actionCreate()
{
    $model = new User();

    if ($model->load(Yii::$app->request->post()) && $model->validate()) {

        $model->setPassword($model->password);
        $model->generateAuthKey();
        $model->save();

        return $this->redirect(['view', 'id' => $model->id]);
    } else {
        return $this->render('create', [
            'model' => $model,
        ]);
    }
}

/**
 * Updates an existing User model.
 * If update is successful, the browser will be redirected to the 'view' page.
 * @param integer $id
 * @return mixed
 */
public function actionUpdate($id)
{
    $model = $this->findModel($id);
    $model->password = $model->password_hash;

    if ($model->load(Yii::$app->request->post()) && $model->validate()) {
        if($model->password_hash!=$model->password ){
             $model->setPassword($model->password);
        }
        $model->save();
        return $this->redirect(['view', 'id' => $model->id]);
    } else {
        return $this->render('update', [
            'model' => $model,
        ]);
    }
}

<?= GridView::widget([
        'dataProvider' => $dataProvider,
        'filterModel' => $searchModel,
        'columns' => [
          //  ['class' => 'yii\grid\SerialColumn'],

            'id',
            'username',
            // 'auth_key',
            // 'password_hash',
            // 'password_reset_token',
            'email:email',

            //'created_at',

            'updated_at:dateTime',
            //'roleName',
            [
              'attribute'=>'role',
              'filter'=>User::getItemsAlias('role'),
              'value'=>function($model){
                return $model->roleName;
              }
            ],
            //'statusName',
            [
              'attribute'=>'status',
              'filter'=>User::getItemsAlias('status'),
              'value'=>function($model){
                return $model->statusName;
              }
            ],

            [
            'class' => 'yii\grid\ActionColumn',
            'options'=>['style'=>'width:120px;'],
            'buttonOptions'=>['class'=>'btn btn-default'],
            'template'=>'<div class="btn-group btn-group-sm text-center" role="group"> {view} {update} {delete} </div>'
            ],
        ],
    ]); ?>

<?= DetailView::widget([
      'model' => $model,
      'attributes' => [
          'id',
          'username',
          'email:email',
          'statusName',
          'created_at:dateTime',
          'updated_at:dateTime',
          'roleName',
      ],
  ]) ?>

<?php

use yii\helpers\Html;
use yii\bootstrap\ActiveForm;

/* @var $this yii\web\View */
/* @var $model common\models\User */
/* @var $form yii\widgets\ActiveForm */
?>

<div class="user-form">

    <?php $form = ActiveForm::begin(); ?>

    <?= $form->field($model, 'username')->textInput(['maxlength' => true]) ?>
    <?= $form->field($model, 'password')->passwordInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'email')->textInput(['maxlength' => true]) ?>

    <div class="row">
        <div class="col-xs-6">
            <?= $form->field($model, 'status')->inline()->radioList($model->getItemStatus()) ?>
        </div>
        <div class="col-xs-6">
            <?= $form->field($model, 'role')->inline()->radioList($model->getItemRole()) ?>
        </div>
    </div>

    <div class="form-group">
        <?= Html::submitButton($model->isNewRecord ? Yii::t('app', 'Create') : Yii::t('app', 'Update'), ['class' => $model->isNewRecord ? 'btn btn-success' : 'btn btn-primary']) ?>
    </div>

    <?php ActiveForm::end(); ?>

</div>