XCube_ActionForm.class.php

<?php
 
if ( ! defined( 'XCUBE_CORE_PATH' ) ) {
    define( 'XCUBE_CORE_PATH', __DIR__ );
}
 
require_once XCUBE_CORE_PATH . '/XCube_Root.class.php';
 
require_once XCUBE_CORE_PATH . '/XCube_Property.class.php';
require_once XCUBE_CORE_PATH . '/XCube_Validator.class.php';
require_once XCUBE_CORE_PATH . '/XCube_FormFile.class.php';
 
 
class XCube_ActionForm {
    public $mContext;

    public $mUser;

    public $mFormProperties = [];

    public $mFieldProperties = [];

    public $mErrorFlag = false;

    public $mErrorMessages = [];

    public $_mToken;

    public function __construct() {
        $root           =& XCube_Root::getSingleton();
        $this->mContext =& $root->getContext();
        $this->mUser    =& $this->mContext->getUser();
    }

    public function prepare() {
    }

    public function getTokenName() {
        return null;
    }

    public function getToken() {
        if ( null === $this->_mToken ) {
            mt_srand( (int) (microtime( true ) * 100000) );
            $root          =& XCube_Root::getSingleton();
            $salt          = $root->getSiteConfig( 'Cube', 'Salt' );
            $this->_mToken = md5( $salt . uniqid( random_int(0, mt_getrandmax()), true ) );
 
            $_SESSION['XCUBE_TOKEN'][ $this->getTokenName() ] = $this->_mToken;
        }
 
        return $this->_mToken;
    }

    public function getTokenErrorMessage() {
        return _TOKEN_ERROR;    //< FIXME
    }

    public function set() {
        if ( isset( $this->mFormProperties[ func_get_arg( 0 ) ] ) ) {
            if ( func_num_args() === 2 ) {
                $value = func_get_arg( 1 );
                $this->mFormProperties[ func_get_arg( 0 ) ]->setValue( $value );
            } elseif ( func_num_args() === 3 ) {
                $index = func_get_arg( 1 );
                $value = func_get_arg( 2 );
                $this->mFormProperties[ func_get_arg( 0 ) ]->setValue( $index, $value );
            }
        }
    }

    public function setVar() {
        if ( isset( $this->mFormProperties[ func_get_arg( 0 ) ] ) ) {
            if ( func_num_args() === 2 ) {
                $this->mFormProperties[ func_get_arg( 0 ) ]->setValue( func_get_arg( 1 ) );
            } elseif ( func_num_args() === 3 ) {
                $this->mFormProperties[ func_get_arg( 0 ) ]->setValue( func_get_arg( 1 ), func_get_arg( 2 ) );
            }
        }
    }

    public function get( $key, $index = null ) {
        return isset( $this->mFormProperties[ $key ] ) ? $this->mFormProperties[ $key ]->getValue( $index ) : null;
    }

    public function getVar( $key, $index = null ) {
        return $this->get( $key, $index );
    }

    public function &getFormProperties() {
        return $this->mFormProperties;
    }

    public function fetch() {
        foreach ( array_keys( $this->mFormProperties ) as $name ) {
            if ( $this->mFormProperties[ $name ]->hasFetchControl() ) {
                $this->mFormProperties[ $name ]->fetch( $this );
            } else {
                $value = $this->mContext->mRequest->getRequest( $name );
                $this->mFormProperties[ $name ]->set( $value );
            }
            $methodName = 'fetch' . ucfirst( $name );
            if ( method_exists( $this, $methodName ) ) {
                // call_user_func(array($this,$methodName));
                $this->$methodName();
            }
        }
    }

    public function _validateToken() {
        //
        // check one-time & transaction token
        //
        if ( null !== $this->getTokenName() ) {
            $key   = str_replace( '.', '_', $this->getTokenName() );
            $token = $_REQUEST[ $key ] ?? null;
 
            $flag = true;
 
            if ( ! isset( $_SESSION['XCUBE_TOKEN'][ $this->getTokenName() ] ) ) {
                $flag = false;
            } elseif ( $_SESSION['XCUBE_TOKEN'][ $this->getTokenName() ] != $token ) {
                unset( $_SESSION['XCUBE_TOKEN'][ $this->getTokenName() ] );
                $flag = false;
            }
 
            if ( ! $flag ) {
                $message = $this->getTokenErrorMessage();
                if ( null === $message ) {
                    $this->mErrorFlag = true;
                } else {
                    $this->addErrorMessage( $message );
                }
            }
 
            //
            // clear token
            //
            unset( $_SESSION['XCUBE_TOKEN'][ $this->getTokenName() ] );
        }
    }
 

    public function validate() {
        $this->_validateToken();
 
        foreach ( array_keys( $this->mFormProperties ) as $name ) {
            if ( isset( $this->mFieldProperties[ $name ] ) ) {
                if ( $this->mFormProperties[ $name ]->isArray() ) {
                    foreach ( array_keys( $this->mFormProperties[ $name ]->mProperties ) as $_name ) {
                        $this->mFieldProperties[ $name ]->validate( $this->mFormProperties[ $name ]->mProperties[ $_name ] );
                    }
                } else {
                    $this->mFieldProperties[ $name ]->validate( $this->mFormProperties[ $name ] );
                }
            }
        }
 
        //
        // If this class has original validation methods, call them.
        //
        foreach ( array_keys( $this->mFormProperties ) as $name ) {
            $methodName = 'validate' . ucfirst( $name );
            if ( method_exists( $this, $methodName ) ) {
                // call_user_func(array($this,$methodName));
                $this->$methodName();
            }
        }
    }

    public function hasError() {
        return ( count( $this->mErrorMessages ) > 0 || $this->mErrorFlag );
    }

    public function addErrorMessage( $message ) {
        $this->mErrorMessages[] = $message;
    }

    public function getErrorMessages() {
        return $this->mErrorMessages;
    }

    public function load( &$obj ) {
    }

    public function update( &$obj ) {
    }
}

class XCube_FieldProperty {
    public $mForm;

    public $mDepends;

    public $mMessages;

    public $mVariables;

    public function __construct( &$form ) {
        $this->mForm =& $form;
    }

    public function setDependsByArray( $dependsArr ) {
        foreach ( $dependsArr as $dependName ) {
            $instance =& XCube_DependClassFactory::factoryClass( $dependName );
            if ( null !== $instance ) {
                $this->mDepends[ $dependName ] =& $instance;
            }
 
            unset( $instance );
        }
    }

    public function addMessage( $name, $message ) {
        if ( func_num_args() >= 2 ) {
            $args                                   = func_get_args();
            $this->mMessages[ $args[0] ]['message'] = $args[1];
            for ( $i = 0; isset( $args[ $i + 2 ] ); $i ++ ) {
                $this->mMessages[ $args[0] ]['args'][ $i ] = $args[ $i + 2 ];
            }
        }
    }

    public function renderMessage(string $name ) {
        if ( ! isset( $this->mMessages[ $name ] ) ) {
            return null;
        }
 
        $message = $this->mMessages[ $name ]['message'];
 
        if ( isset( $this->mMessages[ $name ]['args'] ) ) {
            // Use a unity method.
            $message = XCube_Utils::formatString( $message, $this->mMessages[ $name ]['args'] );
        }
 
        return $message;
    }

    public function addVar( $name, $value ) {
        $this->mVariables[ $name ] = $value;
    }

    public function validate( &$form ) {
        if ( is_array( $this->mDepends ) && count( $this->mDepends ) > 0 ) {
            foreach ( $this->mDepends as $name => $depend ) {
                if ( ! $depend->isValid( $form, $this->mVariables ) ) {
                    // Error
                    // NOTICE: This is temporary until we decide how to handle the errors.
                    $this->mForm->mErrorFlag = true;
 
                    // TEST!!
                    $this->mForm->addErrorMessage( $this->renderMessage( $name ) );
                } else {
                    // OK check
                    return null;
                }
            }
        }
    }
}

class XCube_DependClassFactory {
    public static function &factoryClass(string $dependName ) {
        static $_cache;
 
        if ( ! is_array( $_cache ) ) {
            $_cache = [];
        }
 
        if ( ! isset( $_cache[ $dependName ] ) ) {
            // or switch?
            $class_name = 'XCube_' . ucfirst( $dependName ) . 'Validator';
            if ( XC_CLASS_EXISTS( $class_name ) ) {
                $_cache[ $dependName ] = new $class_name();
            } else {
                // FIXME:: use delegate?
                die( "This is an error message of Alpha or Beta series. {$dependName} Validator is not found." );
            }
        }
 
        return $_cache[ $dependName ];
    }
}