Changeset 133

Show
Ignore:
Timestamp:
01/21/07 11:48:37 (2 years ago)
Author:
mikey
Message:

simplied net.stubbles.ipo.request.stubRequest
added stubRequest::SOURCE_COOKIE, stubRequest::SOURCE_HEADER and stubRequest::SOURCE_PARAM

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/src/main/php/net/stubbles/ipo/request/stubBaseRequest.php

    r97 r133  
    2121     * @var  array<string,string> 
    2222     */ 
    23     protected $unsecureValues  = array(); 
     23    protected $unsecureParams  = array(); 
    2424    /** 
    2525     * list of unfiltered header data 
    …… 
    2929    protected $unsecureHeaders = array(); 
    3030    /** 
    31      * list of errors that occurred while applying a filter 
     31     * list of unfiltered cookie data 
     32     * 
     33     * @var  array<string,string> 
     34     */ 
     35    protected $unsecureCookies = array(); 
     36    /** 
     37     * list of errors that occurred while applying a filter on a param value 
    3238     *  
    3339     * @var  array<string,array<stubRequestValueError>> 
    3440     */ 
    35     protected $valueErrors     = array(); 
    36     /** 
    37      * list of errors that occurred while applying a filter 
     41    protected $paramErrors     = array(); 
     42    /** 
     43     * list of errors that occurred while applying a filter on a header value 
    3844     *  
    3945     * @var  array<string,array<stubRequestValueError>> 
    …… 
    4147    protected $headerErrors    = array(); 
    4248    /** 
     49     * list of errors that occurred while applying a filter on a cookie value 
     50     *  
     51     * @var  array<string,array<stubRequestValueError>> 
     52     */ 
     53    protected $cookieErrors    = array(); 
     54    /** 
    4355     * switch whether request has been cancelled or not 
    4456     * 
    …… 
    5163     * 
    5264     * @param   string  $valueName  name of request value 
    53      * @return  bool 
    54      */ 
    55     public function hasValue($valueName) 
    56     { 
    57         return isset($this->unsecureValues[$valueName]); 
    58     } 
    59      
    60     /** 
    61      * checks whether a request header is set or not 
    62      * 
    63      * @param   string  $headerName  name of request header 
    64      * @return  bool 
    65      */ 
    66     public function hasHeader($headerName) 
    67     { 
    68          return isset($this->unsecureHeaders[$headerName]); 
     65     * @param   int     $source     optional  source type: cookie, header, param 
     66     * @return  bool 
     67     */ 
     68    public function hasValue($valueName, $source = stubRequest::SOURCE_PARAM) 
     69    { 
     70        $data = $this->getValues($source); 
     71        return isset($data[$valueName]); 
    6972    } 
    7073     
    …… 
    7376     * 
    7477     * @param   string  $valueName  name of request value 
    75      * @return  bool 
    76      */ 
    77     public function hasValueError($valueName) 
    78     { 
    79         return isset($this->valueErrors[$valueName]); 
    80     } 
    81      
    82     /** 
    83      * checks whether a request header has an error after a filter was applied 
    84      * 
    85      * @param   string  $headerName  name of request header 
    86      * @return  bool 
    87      */ 
    88     public function hasHeaderError($headerName) 
    89     { 
    90         return isset($this->headerErrors[$headerName]); 
     78     * @param   int     $source     optional  source type: cookie, header, param 
     79     * @return  bool 
     80     */ 
     81    public function hasValueError($valueName, $source = stubRequest::SOURCE_PARAM) 
     82    { 
     83        $error = $this->getErrors($source); 
     84        return isset($error[$valueName]); 
    9185    } 
    9286     
    …… 
    9589     * 
    9690     * @param   string  $valueName  name of request value 
     91     * @param   int     $source     optional  source type: cookie, header, param 
    9792     * @return  array<stubRequestValueError> 
    9893     */ 
    99     public function getValueError($valueName) 
    100     { 
    101         if (isset($this->valueErrors[$valueName]) == true) { 
    102             return $this->valueErrors[$valueName]; 
     94    public function getValueError($valueName, $source = stubRequest::SOURCE_PARAM) 
     95    { 
     96        $error = $this->getErrors($source); 
     97        if (isset($error[$valueName]) == true) { 
     98            return $error[$valueName]; 
    10399        } 
    104100         
    …… 
    107103     
    108104    /** 
    109      * returns a list of errors for given request header 
    110      * 
    111      * @param   string  $headerName  name of request value 
    112      * @return  array<stubRequestValueError> 
    113      */ 
    114     public function getHeaderError($headerName) 
    115     { 
    116         if (isset($this->headerErrors[$headerName]) == true) { 
    117             return $this->headerErrors[$headerName]; 
    118         } 
    119          
    120         return array(); 
    121     } 
    122      
    123     /** 
    124105     * returns a list of all request value names with their errors 
    125106     * 
     107     * @param   int  $source  optional  source type: cookie, header, param 
    126108     * @return  array<string,array<stubRequestValueError>> 
    127109     */ 
    128     public function getValueErrors() 
    129     { 
    130         return $this->valueErrors; 
    131     } 
    132      
    133     /** 
    134      * returns a list of all request header names with their errors 
    135      * 
    136      * @return  array<string,array<stubRequestValueError>> 
    137      */ 
    138     public function getHeaderErrors() 
    139     { 
    140         return $this->headerErrors; 
     110    public function getValueErrors($source = stubRequest::SOURCE_PARAM) 
     111    { 
     112        return $this->getErrors($source); 
     113    } 
     114     
     115    /** 
     116     * returns the array with errors from requested source 
     117     * 
     118     * @param   int  $source  source type: cookie, header, param 
     119     * @return  array<string,string> 
     120     */ 
     121    protected function &getErrors($source) 
     122    { 
     123        switch ($source) { 
     124            case stubRequest::SOURCE_PARAM: 
     125                return $this->paramErrors; 
     126                 
     127            case stubRequest::SOURCE_COOKIE: 
     128                return $this->cookieErrors; 
     129                 
     130            case stubRequest::SOURCE_HEADER: 
     131                return $this->headerErrors; 
     132             
     133            default: 
     134                return $this->paramErrors; 
     135        } 
    141136    } 
    142137     
    …… 
    177172     * @param   stubValidator  $validator  validator to use 
    178173     * @param   string         $valueName  name of request value 
    179      * @return  bool 
    180      */ 
    181     public final function validateValue(stubValidator $validator, $valueName) 
    182     { 
    183         if (isset($this->unsecureValues[$valueName]) == true) { 
    184             return $validator->validate($this->unsecureValues[$valueName]); 
    185         } 
    186          
    187         return false; 
    188     } 
    189      
    190     /** 
    191      * checks whether a request header is valid or nor 
    192      * 
    193      * @param   stubValidator  $validator   validator to use 
    194      * @param   string         $headerName  name of request header 
    195      * @return  bool 
    196      */ 
    197     public final function validateHeader(stubValidator $validator, $headerName) 
    198     { 
    199         if (isset($this->unsecureHeaders[$headerName]) == true) { 
    200             return $validator->validate($this->unsecureHeaders[$headerName]); 
     174     * @param   int            $source     optional  source type: cookie, header, param 
     175     * @return  bool 
     176     */ 
     177    public function validateValue(stubValidator $validator, $valueName, $source = stubRequest::SOURCE_PARAM) 
     178    { 
     179        $data = $this->getValues($source); 
     180        if (isset($data[$valueName]) == true) { 
     181            return $validator->validate($data[$valueName]); 
    201182        } 
    202183         
    …… 
    211192     * @param   stubValidator  $validator  validator to use 
    212193     * @param   string         $valueName  name of request value 
     194     * @param   int            $source     optional  source type: cookie, header, param 
    213195     * @return  string 
    214196     */ 
    215     public final function getValidatedValue(stubValidator $validator, $valueName) 
    216     { 
    217         if (isset($this->unsecureValues[$valueName]) == true 
    218         && $validator->validate($this->unsecureValues[$valueName]) == true) { 
    219             return $this->unsecureValues[$valueName]; 
     197    public function getValidatedValue(stubValidator $validator, $valueName, $source = stubRequest::SOURCE_PARAM) 
     198    { 
     199        $data = $this->getValues($source); 
     200        if (isset($data[$valueName]) == true && $validator->validate($data[$valueName]) == true) { 
     201            return $data[$valueName]; 
    220202        } 
    221203         
    222204        return null; 
    223205    } 
    224      
    225     /** 
    226      * returns the validated request header 
    227      *  
    228      * If the validator says the header is not valid the return value is null. 
    229      * 
    230      * @param   stubValidator  $validator   validator to use 
    231      * @param   string         $headerName  name of request value 
    232      * @return  string 
    233      */ 
    234     public final function getValidatedHeader(stubValidator $validator, $headerName) 
    235     { 
    236         if (isset($this->unsecureHeaders[$headerName]) == true 
    237          && $validator->validate($this->unsecureHeaders[$headerName]) == true) { 
    238             return $this->unsecureHeaders[$headerName]; 
    239         } 
    240          
    241         return null; 
    242     } 
    243      
     206 
    244207    /** 
    245208     * returns a filtered request value 
    …… 
    247210     * @param   stubFilter  $filter     filter to use 
    248211     * @param   string      $paramName  name of request value 
     212     * @param   int         $source     optional  source type: cookie, header, param 
    249213     * @return  mixed 
    250214     * @throws  stubFilterException 
    251215     */ 
    252     public final function getFilteredValue(stubFilter $filter, $valueName) 
    253     { 
    254         if (isset($this->unsecureValues[$valueName]) == false) { 
     216    public function getFilteredValue(stubFilter $filter, $valueName, $source = stubRequest::SOURCE_PARAM) 
     217    { 
     218        $data = $this->getValues($source); 
     219        if (isset($data[$valueName]) == false) { 
    255220            if ($filter->hasDefaultValue() == true) { 
    256221                return $filter->getDefaultValue(); 
    …… 
    261226             
    262227        try { 
    263             $value = $filter->execute($this->unsecureValues[$valueName]); 
     228            $value = $filter->execute($data[$valueName]); 
    264229        } catch (stubFilterException $fe) { 
    265             if (isset($this->valueErrors[$valueName]) == false) { 
    266                 $this->valueErrors[$valueName] = array(); 
     230            $error =& $this->getErrors($source); 
     231            if (isset($error[$valueName]) == false) { 
     232                $error[$valueName] = array(); 
    267233            } 
    268234             
    269             $this->valueErrors[$valueName][] = $fe->getError(); 
     235            $error[$valueName][] = $fe->getError(); 
    270236            return null; 
    271237        } 
    …… 
    275241     
    276242    /** 
    277      * returns a filtered request header 
    278      * 
    279      * @param   stubFilter  $filter      filter to use 
    280      * @param   string      $headerName  name of request value 
    281      * @return  mixed 
    282      * @throws  stubFilterException 
    283      */ 
    284     public final function getFilteredHeader(stubFilter $filter, $headerName) 
    285     { 
    286         if (isset($this->unsecureHeaders[$headerName]) == false) { 
    287             if ($filter->hasDefaultValue() == true) { 
    288                 return $filter->getDefaultValue(); 
    289             } 
    290              
    291             return null; 
    292         } 
    293              
    294         try { 
    295             $value = $filter->execute($this->unsecureHeaders[$headerName]); 
    296         } catch (stubFilterException $fe) { 
    297             if (isset($this->headerErrors[$headerName]) == false) { 
    298                 $this->headerErrors[$headerName] = array(); 
    299             } 
    300              
    301             $this->headerErrors[$headerName][] = $fe->getError(); 
    302             return null; 
    303         } 
    304          
    305         return $value; 
     243     * returns the array with data from requested source 
     244     * 
     245     * @param   int  $source  source type: cookie, header, param 
     246     * @return  array<string,string> 
     247     */ 
     248    protected function getValues($source) 
     249    { 
     250        switch ($source) { 
     251            case stubRequest::SOURCE_PARAM: 
     252                return $this->unsecureParams; 
     253                 
     254            case stubRequest::SOURCE_COOKIE: 
     255                return $this->unsecureCookies; 
     256                 
     257            case stubRequest::SOURCE_HEADER: 
     258                return $this->unsecureHeaders; 
     259             
     260            default: 
     261                return $this->unsecureParams; 
     262        } 
    306263    } 
    307264} 

  • trunk/src/main/php/net/stubbles/ipo/request/stubRequest.php

    r97 r133  
    2323     */ 
    2424    const EVENT_CANCELLED = 'onRequestCancelled'; 
     25    /** 
     26     * request source: cookies 
     27     */ 
     28    const SOURCE_COOKIE   = 1; 
     29    /** 
     30     * request source: header 
     31     */ 
     32    const SOURCE_HEADER   = 2; 
     33    /** 
     34     * request source: parameters 
     35     */ 
     36    const SOURCE_PARAM    = 4; 
    2537     
    2638    /** 
    …… 
    2840     * 
    2941     * @param   string  $valueName  name of request value 
     42     * @param   int     $source     optional  source type: cookie, header, param 
    3043     * @return  bool 
    3144     */ 
    32     public function hasValue($valueName); 
    33      
    34     /** 
    35      * checks whether a request header is set or not 
    36      * 
    37      * @param   string  $headerName  name of request header 
    38      * @return  bool 
    39      */ 
    40     public function hasHeader($headerName); 
     45    public function hasValue($valueName, $source = self::SOURCE_PARAM); 
    4146     
    4247    /** 
    …… 
    4449     * 
    4550     * @param   string  $valueName  name of request value 
     51     * @param   int     $source     optional  source type: cookie, header, param 
    4652     * @return  bool 
    4753     */ 
    48     public function hasValueError($valueName); 
    49      
    50     /** 
    51      * checks whether a request header has an error after a filter was applied 
    52      * 
    53      * @param   string  $headerName  name of request header 
    54      * @return  bool 
    55      */ 
    56     public function hasHeaderError($headerName); 
     54    public function hasValueError($valueName, $source = self::SOURCE_PARAM); 
    5755     
    5856    /** 
    …… 
    6058     * 
    6159     * @param   string  $valueName  name of request value 
     60     * @param   int     $source     optional  source type: cookie, header, param 
    6261     * @return  array<stubRequestValueError> 
    6362     */ 
    64     public function getValueError($valueName); 
    65      
    66     /** 
    67      * returns a list of errors for given request header 
    68      * 
    69      * @param   string  $headerName  name of request value 
    70      * @return  array<stubRequestValueError> 
    71      */ 
    72     public function getHeaderError($headerName); 
     63    public function getValueError($valueName, $source = self::SOURCE_PARAM); 
    7364     
    7465    /** 
    7566     * returns a list of all request value names with their errors 
    7667     * 
     68     * @param   int  $source  optional  source type: cookie, header, param 
    7769     * @return  array<string,array<stubRequestValueError>> 
    7870     */ 
    79     public function getValueErrors(); 
    80      
    81     /** 
    82      * returns a list of all request header names with their errors 
    83      * 
    84      * @return  array<string,array<stubRequestValueError>> 
    85      */ 
    86     public function getHeaderErrors(); 
     71    public function getValueErrors($source = self::SOURCE_PARAM); 
    8772     
    8873    /** 
    …… 
    10792     * @param   stubValidator  $validator  validator to use 
    10893     * @param   string         $valueName  name of request value 
     94     * @param   int            $source     optional  source type: cookie, header, param 
    10995     * @return  bool 
    11096     */ 
    111     public function validateValue(stubValidator $validator, $valueName); 
    112      
    113     /** 
    114      * checks whether a request header is valid or nor 
    115      * 
    116      * @param   stubValidator  $validator   validator to use 
    117      * @param   string         $headerName  name of request header 
    118      * @return  bool 
    119      */ 
    120     public function validateHeader(stubValidator $validator, $headerName); 
     97    public function validateValue(stubValidator $validator, $valueName, $source = self::SOURCE_PARAM); 
    12198     
    12299    /** 
    …… 
    127104     * @param   stubValidator  $validator  validator to use 
    128105     * @param   string         $valueName  name of request value 
     106     * @param   int            $source     optional  source type: cookie, header, param 
    129107     * @return  string 
    130108     */ 
    131     public function getValidatedValue(stubValidator $validator, $valueName); 
    132      
    133     /** 
    134      * returns the validated request header 
    135      *  
    136      * If the validator says the header is not valid the return value is null. 
    137      * 
    138      * @param   stubValidator  $validator   validator to use 
    139      * @param   string         $headerName  name of request value 
    140      * @return  string 
    141      */ 
    142     public function getValidatedHeader(stubValidator $validator, $headerName); 
    143      
     109    public function getValidatedValue(stubValidator $validator, $valueName, $source = self::SOURCE_PARAM); 
     110 
    144111    /** 
    145112     * returns a filtered request value 
    …… 
    147114     * @param   stubFilter  $filter     filter to use 
    148115     * @param   string      $paramName  name of request value 
     116     * @param   int         $source     optional  source type: cookie, header, param 
    149117     * @return  mixed 
    150118     * @throws  stubFilterException 
    151119     */ 
    152     public function getFilteredValue(stubFilter $filter, $valueName); 
    153      
    154     /** 
    155      * returns a filtered request header 
    156      * 
    157      * @param   stubFilter  $filter      filter to use 
    158      * @param   string      $headerName  name of request value 
    159      * @return  mixed 
    160      * @throws  stubFilterException 
    161      */ 
    162     public function getFilteredHeader(stubFilter $filter, $headerName); 
     120    public function getFilteredValue(stubFilter $filter, $valueName, $source = self::SOURCE_PARAM); 
    163121} 
    164122?> 

  • trunk/src/main/php/net/stubbles/ipo/request/stubRequestPrefixDecorator.php

    r97 r133  
    2828     */ 
    2929    protected $prefix; 
     30    /** 
     31     * sources to apply prefix on 
     32     *  
     33     * Can be any of stubRequest::SOURCE_* or a combination of them (bit value) 
     34     * 
     35     * @var  int 
     36     */ 
     37    protected $sources; 
    3038     
    3139    /** 
    …… 
    3442     * @param  stubRequest  $request  the request to decorate 
    3543     * @param  string       $prefix   the prefix to use 
    36      */ 
    37     public function __construct(stubRequest $request, $prefix) 
     44     * @param  int          $sources  optional  can be any of stubRequest::SOURCE_* or a combination of them (bit value) 
     45     */ 
     46    public function __construct(stubRequest $request, $prefix, $sources = stubRequest::SOURCE_PARAM) 
    3847    { 
    3948        $this->request = $request; 
    4049        $this->prefix  = $prefix; 
     50        $this->sources = $sources; 
    4151    } 
    4252     
    …… 
    4555     * 
    4656     * @param   string  $valueName  name of request value 
    47      * @return  bool 
    48      */ 
    49     public function hasValue($valueName) 
    50     { 
    51         return $this->request->hasValue($this->prefix . '_' . $valueName); 
    52     } 
    53      
    54     /** 
    55      * checks whether a request header is set or not 
    56      * 
    57      * @param   string  $headerName  name of request header 
    58      * @return  bool 
    59      */ 
    60     public function hasHeader($headerName) 
    61     { 
    62          return $this->request->hasHeader($headerName); 
     57     * @param   int     $source     optional  source type: cookie, header, param 
     58     * @return  bool 
     59     */ 
     60    public function hasValue($valueName, $source = stubRequest::SOURCE_PARAM) 
     61    { 
     62        if ($this->applyPrefix($source) == true) { 
     63            $valueName = $this->prefix . '_' . $valueName; 
     64        } 
     65         
     66        return $this->request->hasValue($valueName, $source); 
    6367    } 
    6468     
    …… 
    6771     * 
    6872     * @param   string  $valueName  name of request value 
    69      * @return  bool 
    70      */ 
    71     public function hasValueError($valueName) 
    72     { 
    73         return $this->request->hasValueError($this->prefix . '_' . $valueName); 
    74     } 
    75      
    76     /** 
    77      * checks whether a request header has an error after a filter was applied 
    78      * 
    79      * @param   string  $headerName  name of request header 
    80      * @return  bool 
    81      */ 
    82     public function hasHeaderError($headerName) 
    83     { 
    84         return $this->request->hasHeaderError($headerName); 
    85     } 
    86      
     73     * @param   int     $source     optional  source type: cookie, header, param 
     74     * @return  bool 
     75     */ 
     76    public function hasValueError($valueName, $source = stubRequest::SOURCE_PARAM) 
     77    { 
     78        if ($this->applyPrefix($source) == true) { 
     79            $valueName = $this->prefix . '_' . $valueName; 
     80        } 
     81         
     82        return $this->request->hasValueError($valueName, $source); 
     83    } 
     84 
    8785    /** 
    8886     * returns a list of errors for given request value 
    8987     * 
    9088     * @param   string  $valueName  name of request value 
     89     * @param   int     $source     optional  source type: cookie, header, param 
    9190     * @return  array<stubRequestValueError> 
    9291     */ 
    93     public function getValueError($valueName) 
    94     { 
    95         return $this->request->getValueError($this->prefix . '_' . $valueName); 
    96     } 
    97      
    98     /** 
    99      * returns a list of errors for given request header 
    100      * 
    101      * @param   string  $headerName  name of request value 
    102      * @return  array<stubRequestValueError> 
    103      */ 
    104     public function getHeaderError($headerName) 
    105     { 
    106         return $this->request->getHeaderError($headerName); 
    107     } 
    108      
     92    public function getValueError($valueName, $source = stubRequest::SOURCE_PARAM) 
     93    { 
     94        if ($this->applyPrefix($source) == true) { 
     95            $valueName = $this->prefix . '_' . $valueName; 
     96        } 
     97         
     98        return $this->request->getValueError($valueName, $source); 
     99    } 
     100 
    109101    /** 
    110102     * returns a list of all request value names with their errors 
    111103     * 
     104     * @param   int  $source  optional  source type: cookie, header, param 
    112105     * @return  array<string,array<stubRequestValueError>> 
    113106     */ 
    114     public function getValueErrors() 
    115     { 
    116         $valueErrors   = $this->request->getValueErrors(); 
    117         $returedErrors = array(); 
    118         $checkLength   = strlen($this->prefix) + 1; 
     107    public function getValueErrors($source = stubRequest::SOURCE_PARAM) 
     108    { 
     109        $valueErrors   = $this->request->getValueErrors($source); 
     110        if ($this->applyPrefix($source) == false) { 
     111            return $valueErrors; 
     112        } 
     113         
     114        $returnedErrors = array(); 
     115        $checkLength    = strlen($this->prefix) + 1; 
    119116        foreach ($valueErrors as $valueName => $valueErrorList) { 
    120117            if (substr($valueName, 0, $checkLength) == $this->prefix . '_') { 
    121                 $returedErrors[str_replace($this->prefix . '_', '', $valueName)] = $valueErrorList; 
     118                $returnedErrors[str_replace($this->prefix . '_', '', $valueName)] = $valueErrorList; 
    122119            } 
    123120        } 
    124121         
    125         return $returedErrors; 
    126     } 
    127      
    128     /** 
    129      * returns a list of all request header names with their errors 
    130      * 
    131      * @return  array<string,array<stubRequestValueError>> 
    132      */ 
    133     public function getHeaderErrors() 
    134     { 
    135         return $this->request->getHeaderErrors(); 
    136     } 
    137      
     122        return $returnedErrors; 
     123    } 
     124 
    138125    /** 
    139126     * cancels the request, e.g. if it was detected that it is invalid 
    …… 
    163150     * @param   stubValidator  $validator  validator to use 
    164151     * @param   string         $valueName  name of request value 
    165      * @return  bool 
    166      */ 
    167     public final function validateValue(stubValidator $validator, $valueName) 
    168     { 
    169         return $this->request->validateValue($validator, $this->prefix . '_' . $valueName); 
    170     } 
    171      
    172     /** 
    173      * checks whether a request header is valid or nor 
    174      * 
    175      * @param   stubValidator  $validator   validator to use 
    176      * @param   string         $headerName  name of request header 
    177      * @return  bool 
    178      */ 
    179     public final function validateHeader(stubValidator $validator, $headerName) 
    180     { 
    181         return $this->request->validateHeader($validator, $headerName); 
    182     } 
    183      
     152     * @param   int            $source     optional  source type: cookie, header, param 
     153     * @return  bool 
     154     */ 
     155    public function validateValue(stubValidator $validator, $valueName, $source = stubRequest::SOURCE_PARAM) 
     156    { 
     157        if ($this->applyPrefix($source) == true) { 
     158            $valueName = $this->prefix . '_' . $valueName; 
     159        } 
     160         
     161        return $this->request->validateValue($validator, $valueName, $source); 
     162    } 
     163 
    184164    /** 
    185165     * returns the validated request value 
    …… 
    189169     * @param   stubValidator  $validator  validator to use 
    190170     * @param   string         $valueName  name of request value 
     171     * @param   int            $source     optional  source type: cookie, header, param 
    191172     * @return  string 
    192173     */ 
    193     public final function getValidatedValue(stubValidator $validator, $valueName) 
    194     { 
    195         return $this->request->getValidatedValue($validator, $this->prefix . '_' . $valueName); 
    196     } 
    197      
    198     /** 
    199      * returns the validated request header 
    200      *  
    201      * If the validator says the header is not valid the return value is null. 
    202      * 
    203      * @param   stubValidator  $validator   validator to use 
    204      * @param   string         $headerName  name of request value 
    205      * @return  string 
    206      */ 
    207     public final function getValidatedHeader(stubValidator $validator, $headerName) 
    208     { 
    209         return $this->request->getValidatedHeader($validator, $headerName); 
    210     } 
    211      
     174    public function getValidatedValue(stubValidator $validator, $valueName, $source = stubRequest::SOURCE_PARAM) 
     175    { 
     176        if ($this->applyPrefix($source) == true) { 
     177            $valueName = $this->prefix . '_' . $valueName; 
     178        } 
     179         
     180        return $this->request->getValidatedValue($validator, $valueName, $source); 
     181    } 
     182 
    212183    /** 
    213184     * returns a filtered request value 
    …… 
    215186     * @param   stubFilter  $filter     filter to use 
    216187     * @param   string      $paramName  name of request value 
     188     * @param   int         $source     optional  source type: cookie, header, param 
    217189     * @return  mixed 
    218190     * @throws  stubFilterException 
    219191     */ 
    220     public final function getFilteredValue(stubFilter $filter, $valueName) 
    221     { 
    222         return $this->request->getFilteredValue($filter, $this->prefix . '_' . $valueName); 
    223     } 
    224      
    225     /** 
    226      * returns a filtered request header 
    227      * 
    228      * @param   stubFilter  $filter      filter to use 
    229      * @param   string      $headerName  name of request value 
    230      * @return  mixed 
    231      * @throws  stubFilterException 
    232      */ 
    233     public final function getFilteredHeader(stubFilter $filter, $headerName) 
    234     { 
    235         return $this->request->getFilteredHeader($filter, $headerName); 
     192    public function getFilteredValue(stubFilter $filter, $valueName, $source = stubRequest::SOURCE_PARAM) 
     193    { 
     194        if ($this->applyPrefix($source) == true) { 
     195            $valueName = $this->prefix . '_' . $valueName; 
     196        } 
     197         
     198        return $this->request->getFilteredValue($filter, $valueName, $source); 
     199    } 
     200     
     201    /** 
     202     * check whether the prefix has to be applied for requested source 
     203     * 
     204     * @param  int  $sources  can be any of stubRequest::SOURCE_* or a combination of them (bit value) 
     205     */ 
     206    protected function applyPrefix($source) 
     207    { 
     208        return (($this->sources & $source) != 0); 
    236209    } 
    237210} 

  • trunk/src/test/php/net/stubbles/ipo/request/stubBaseRequestTestCase.php

    r98 r133  
    1515    public function __construct() 
    1616    { 
    17         $this->unsecureValues  = array('foo' => 'bar'); 
     17        $this->unsecureParams  = array('foo' => 'bar'); 
    1818        $this->unsecureHeaders = array('bar' => 'baz'); 
     19        $this->unsecureCookies = array('baz' => 'foo'); 
    1920    } 
    2021     
    2122    public function setValueError($valueName, stubRequestValueError $error) 
    2223    { 
    23         $this->valueErrors[$valueName] = array($error); 
     24        $this->paramErrors[$valueName] = array($error); 
    2425    } 
    2526     
    …… 
    2728    { 
    2829        $this->headerErrors[$headerName] = array($error); 
     30    } 
     31     
     32    public function setCookieError($cookieName, stubRequestValueError $error) 
     33    { 
     34        $this->cookieErrors[$cookieName] = array($error); 
    2935    } 
    3036} 
    …… 
    6066        $this->assertFalse($this->request->hasValue('baz')); 
    6167         
    62         $mockValidator = new MockStubValidator(); 
    63         $mockValidator->setReturnValueAt(0, 'validate', true); 
    64         $mockValidator->setReturnValueAt(1, 'validate', false); 
    65         $mockValidator->setReturnValueAt(2, 'validate', true); 
     68        $this->assertTrue($this->request->hasValue('foo', stubRequest::SOURCE_PARAM)); 
     69        $this->assertFalse($this->request->hasValue('baz', stubRequest::SOURCE_PARAM)); 
     70         
     71        $this->assertTrue($this->request->hasValue('foo', 'dummy')); 
     72        $this->assertFalse($this->request->hasValue('baz', 'dummy')); 
     73         
     74        $mockValidator = new MockStubValidator(); 
     75        $mockValidator->setReturnValueAt(0, 'validate', true); 
     76        $mockValidator->setReturnValueAt(1, 'validate', false); 
     77        $mockValidator->setReturnValueAt(2, 'validate', true); 
     78        $mockValidator->setReturnValueAt(3, 'validate', false); 
     79        $mockValidator->setReturnValueAt(4, 'validate', true); 
     80        $mockValidator->setReturnValueAt(5, 'validate', false); 
     81        $mockValidator->setReturnValueAt(6, 'validate', true); 
    6682        $this->assertTrue($this->request->validateValue($mockValidator, 'foo')); 
    6783        $this->assertFalse($this->request->validateValue($mockValidator, 'foo')); 
    6884        $this->assertFalse($this->request->validateValue($mockValidator, 'baz')); 
    6985         
    70         $mockValidator = new MockStubValidator(); 
    71         $mockValidator->setReturnValueAt(0, 'validate', true); 
    72         $mockValidator->setReturnValueAt(1, 'validate', false); 
    73         $mockValidator->setReturnValueAt(2, 'validate', true); 
     86        $this->assertTrue($this->request->validateValue($mockValidator, 'foo', stubRequest::SOURCE_PARAM)); 
     87        $this->assertFalse($this->request->validateValue($mockValidator, 'foo', stubRequest::SOURCE_PARAM)); 
     88        $this->assertFalse($this->request->validateValue($mockValidator, 'baz', stubRequest::SOURCE_PARAM)); 
     89         
     90        $this->assertTrue($this->request->validateValue($mockValidator, 'foo', 'dummy')); 
     91        $this->assertFalse($this->request->validateValue($mockValidator, 'foo', 'dummy')); 
     92        $this->assertFalse($this->request->validateValue($mockValidator, 'baz', 'dummy')); 
     93         
     94        $mockValidator = new MockStubValidator(); 
     95        $mockValidator->setReturnValueAt(0, 'validate', true); 
     96        $mockValidator->setReturnValueAt(1, 'validate', false); 
     97        $mockValidator->setReturnValueAt(2, 'validate', true); 
     98        $mockValidator->setReturnValueAt(3, 'validate', false); 
     99        $mockValidator->setReturnValueAt(4, 'validate', true); 
     100        $mockValidator->setReturnValueAt(5, 'validate', false); 
     101        $mockValidator->setReturnValueAt(6, 'validate', true); 
    74102        $this->assertEqual($this->request->getValidatedValue($mockValidator, 'foo'), 'bar'); 
    75103        $this->assertNull($this->request->getValidatedValue($mockValidator, 'foo')); 
    76104        $this->assertNull($this->request->getValidatedValue($mockValidator, 'baz')); 
    77105         
     106        $this->assertEqual($this->request->getValidatedValue($mockValidator, 'foo', stubRequest::SOURCE_PARAM), 'bar'); 
     107        $this->assertNull($this->request->getValidatedValue($mockValidator, 'foo', stubRequest::SOURCE_PARAM)); 
     108        $this->assertNull($this->request->getValidatedValue($mockValidator, 'baz', stubRequest::SOURCE_PARAM)); 
     109         
     110        $this->assertEqual($this->request->getValidatedValue($mockValidator, 'foo', 'dummy'), 'bar'); 
     111        $this->assertNull($this->request->getValidatedValue($mockValidator, 'foo', 'dummy')); 
     112        $this->assertNull($this->request->getValidatedValue($mockValidator, 'baz', 'dummy')); 
     113         
    78114        $mockFilter = new MockStubFilter(); 
    79115        $mockFilter->setReturnValueAt(0, 'hasDefaultValue', true); 
    80116        $mockFilter->setReturnValueAt(1, 'hasDefaultValue', false); 
     117        $mockFilter->setReturnValueAt(2, 'hasDefaultValue', true); 
     118        $mockFilter->setReturnValueAt(3, 'hasDefaultValue', false); 
     119        $mockFilter->setReturnValueAt(4, 'hasDefaultValue', true); 
     120        $mockFilter->setReturnValueAt(5, 'hasDefaultValue', false); 
    81121        $mockFilter->setReturnValue('getDefaultValue', 'baz'); 
    82122        $mockFilter->setReturnValue('execute', 'bam'); 
    …… 
    84124        $this->assertNull($this->request->getFilteredValue($mockFilter, 'baz')); 
    85125        $this->assertEqual($this->request->getFilteredValue($mockFilter, 'foo'), 'bam'); 
     126         
     127        $this->assertEqual($this->request->getFilteredValue($mockFilter, 'baz', stubRequest::SOURCE_PARAM), 'baz'); 
     128        $this->assertNull($this->request->getFilteredValue($mockFilter, 'baz', stubRequest::SOURCE_PARAM)); 
     129        $this->assertEqual($this->request->getFilteredValue($mockFilter, 'foo', stubRequest::SOURCE_PARAM), 'bam'); 
     130         
     131        $this->assertEqual($this->request->getFilteredValue($mockFilter, 'baz', 'dummy'), 'baz'); 
     132        $this->assertNull($this->request->getFilteredValue($mockFilter, 'baz', 'dummy')); 
     133        $this->assertEqual($this->request->getFilteredValue($mockFilter, 'foo', 'dummy'), 'bam'); 
    86134    } 
    87135     
    …… 
    91139    public function testHeader() 
    92140    { 
    93         $this->assertTrue($this->request->hasHeader('bar')); 
    94         $this->assertFalse($this->request->hasHeader('baz')); 
    95          
    96         $mockValidator = new MockStubValidator(); 
    97         $mockValidator->setReturnValueAt(0, 'validate', true); 
    98         $mockValidator->setReturnValueAt(1, 'validate', false); 
    99         $mockValidator->setReturnValueAt(2, 'validate', true); 
    100         $this->assertTrue($this->request->validateHeader($mockValidator, 'bar')); 
    101         $this->assertFalse($this->request->validateHeader($mockValidator, 'bar')); 
    102         $this->assertFalse($this->request->validateHeader($mockValidator, 'baz')); 
    103          
    104         $mockValidator = new MockStubValidator(); 
    105         $mockValidator->setReturnValueAt(0, 'validate', true); 
    106         $mockValidator->setReturnValueAt(1, 'validate', false); 
    107         $mockValidator->setReturnValueAt(2, 'validate', true); 
    108         $this->assertEqual($this->request->getValidatedHeader($mockValidator, 'bar'), 'baz'); 
    109         $this->assertNull($this->request->getValidatedHeader($mockValidator, 'bar')); 
    110         $this->assertNull($this->request->getValidatedHeader($mockValidator, 'baz')); 
     141        $this->assertTrue($this->request->hasValue('bar', stubRequest::SOURCE_HEADER)); 
     142        $this->assertFalse($this->request->hasValue('baz', stubRequest::SOURCE_HEADER)); 
     143         
     144        $mockValidator = new MockStubValidator(); 
     145        $mockValidator->setReturnValueAt(0, 'validate', true); 
     146        $mockValidator->setReturnValueAt(1, 'validate', false); 
     147        $mockValidator->setReturnValueAt(2, 'validate', true); 
     148        $this->assertTrue($this->request->validateValue($mockValidator, 'bar', stubRequest::SOURCE_HEADER)); 
     149        $this->assertFalse($this->request->validateValue($mockValidator, 'bar', stubRequest::SOURCE_HEADER)); 
     150        $this->assertFalse($this->request->validateValue($mockValidator, 'baz', stubRequest::SOURCE_HEADER)); 
     151         
     152        $mockValidator = new MockStubValidator(); 
     153        $mockValidator->setReturnValueAt(0, 'validate', true); 
     154        $mockValidator->setReturnValueAt(1, 'validate', false); 
     155        $mockValidator->setReturnValueAt(2, 'validate', true); 
     156        $this->assertEqual($this->request->getValidatedValue($mockValidator, 'bar', stubRequest::SOURCE_HEADER), 'baz'); 
     157        $this->assertNull($this->request->getValidatedValue($mockValidator, 'bar', stubRequest::SOURCE_HEADER)); 
     158        $this->assertNull($this->request->getValidatedValue($mockValidator, 'baz', stubRequest::SOURCE_HEADER)); 
    111159         
    112160        $mockFilter = new MockStubFilter(); 
    …… 
    115163        $mockFilter->setReturnValue('getDefaultValue', 'foo'); 
    116164        $mockFilter->setReturnValue('execute', 'bam'); 
    117         $this->assertEqual($this->request->getFilteredHeader($mockFilter, 'baz'), 'foo'); 
    118         $this->assertNull($this->request->getFilteredHeader($mockFilter, 'baz')); 
    119         $this->assertEqual($this->request->getFilteredHeader($mockFilter, 'bar'), 'bam'); 
     165        $this->assertEqual($this->request->getFilteredValue($mockFilter, 'baz', stubRequest::SOURCE_HEADER), 'foo'); 
     166        $this->assertNull($this->request->getFilteredValue($mockFilter, 'baz', stubRequest::SOURCE_HEADER)); 
     167        $this->assertEqual($this->request->getFilteredValue($mockFilter, 'bar', stubRequest::SOURCE_HEADER), 'bam'); 
     168    } 
     169     
     170    /** 
     171     * test that headers are handles as expected 
     172     */ 
     173    public function testCookie() 
     174    { 
     175        $this->assertTrue($this->request->hasValue('baz', stubRequest::SOURCE_COOKIE)); 
     176        $this->assertFalse($this->request->hasValue('foo', stubRequest::SOURCE_COOKIE)); 
     177         
     178        $mockValidator = new MockStubValidator(); 
     179        $mockValidator->setReturnValueAt(0, 'validate', true); 
     180        $mockValidator->setReturnValueAt(1, 'validate', false); 
     181        $mockValidator->setReturnValueAt(2, 'validate', true); 
     182        $this->assertTrue($this->request->validateValue($mockValidator, 'baz', stubRequest::SOURCE_COOKIE)); 
     183        $this->assertFalse($this->request->validateValue($mockValidator, 'baz', stubRequest::SOURCE_COOKIE)); 
     184        $this->assertFalse($this->request->validateValue($mockValidator, 'foo', stubRequest::SOURCE_COOKIE)); 
     185         
     186        $mockValidator = new Mo