Ignore:
Timestamp:
06/15/12 14:49:24 (12 years ago)
Author:
acoutinho
Message:

Ticket #2766 - Melhorias e correcoes na api rest, criacao de novo cliente

Location:
sandbox/2.4.1-3/prototype/rest
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • sandbox/2.4.1-3/prototype/rest/catalog/DynamicContactResource.php

    r6512 r6523  
    11<?php 
    22 
    3 if( !defined( 'ROOTPATH' ) ) 
    4     define( 'ROOTPATH', dirname(__FILE__).'/..' ); 
    5  
    6 require_once(ROOTPATH.'/rest/hypermedia/hypermedia.php'); 
     3if (!defined('ROOTPATH')) 
     4    define('ROOTPATH', dirname(__FILE__) . '/..'); 
     5 
     6require_once(ROOTPATH . '/rest/hypermedia/hypermedia.php'); 
    77 
    88use prototype\api\Config as Config; 
    … …  
    2020     * @access     public 
    2121     * */ 
    22      function get($request, $id){ 
    23  
    24         $response = new Response($request); 
    25         $response->addHeader('Content-type', 'aplication/json'); 
    26         $response->code = Response::OK; 
    27  
    28         $h = new Hypermedia(); 
    29         $c = new Collection($request->resources, 'DynamicContactResource'); 
    30  
    31         try { 
    32 //            $this->secured(); 
    33  
    34             $dynamicContacts = Controller::find(  
    35                                                 array( 'concept' => 'dynamicContact' ),  
    36                                                 false,  
    37                                                 array( 'filter' => array( 'AND', array( '=', 'owner',  Config::me("uidNumber") ) , array('=', 'id', $id) ) )   
    38             ); 
    39  
    40             //Se nao foi encontrado contatos na consulta 
    41             if($dynamicContacts===false){ 
    42                 $error = new Error(); 
    43                 $error->setCode(Response::NOTFOUND); 
    44                 $error->setTitle('Dynamic Contact not found'); 
    45                 $error->setDescription('Dynamic Contact not found.'); 
    46  
    47                 $c->setError($error); 
    48                 $h->setCollection($c); 
    49  
    50                 $response->code = Response::NOTFOUND; 
    51                 $response->body = $h->getHypermedia($request->accept[10][0]); 
    52                 return $response; 
    53             } 
    54  
    55  
    56             $t = new Template(); 
    57             $d = new Data(); 
    58  
    59             $d->setName('name'); 
    60             $d->setValue(null); 
    61             $d->setPrompt('Nome do Contato Recente'); 
    62             $d->setDataType('string'); 
    63             $d->setMaxLength(100); 
    64             $d->setMinLength(null); 
    65             $d->setRequired(true); 
    66  
    67             $t->addData($d); 
    68  
    69             $d = new Data(); 
    70             $d->setName('mail'); 
    71             $d->setValue(null); 
    72             $d->setPrompt('Email do Contato Recente'); 
    73             $d->setDataType('string'); 
    74             $d->setMaxLength(100); 
    75             $d->setMinLength(null); 
    76             $d->setRequired(true); 
    77  
    78             $t->addData($d); 
    79  
    80             $d = new Data(); 
    81             $d->setName('number_of_messages'); 
    82             $d->setValue(null); 
    83             $d->setPrompt('Quantidade de mensagens enviadas'); 
    84             $d->setDataType('integer'); 
    85             $d->setMaxLength(100); 
    86             $d->setMinLength(null); 
    87             $d->setRequired(false); 
    88  
    89             $t->addData($d); 
    90  
    91             $c->setTemplate($t); 
    92  
    93             $d = new Data(); 
    94             $d->setName('id'); 
    95             $d->setValue($dynamicContacts[0]['id']); 
    96             $d->setPrompt('Identificador do Contato Recente'); 
    97             $d->setDataType('integer'); 
    98             $d->setMaxLength(null); 
    99             $d->setMinLength(null); 
    100             $d->setRequired(true); 
    101  
    102             $c->addData($d); 
    103  
    104             $d = new Data(); 
    105  
    106             $d->setName('name'); 
    107             $d->setValue($dynamicContacts[0]['name']); 
    108             $d->setPrompt('Nome do Contato Recente'); 
    109             $d->setDataType('string'); 
    110             $d->setMaxLength('100'); 
    111             $d->setMinLength(null); 
    112             $d->setRequired(true); 
    113  
    114             $c->addData($d); 
    115  
    116             $d = new Data(); 
    117             $d->setName('mail'); 
    118             $d->setValue($dynamicContacts[0]['mail']); 
    119             $d->setPrompt('Email do Contato Recente'); 
    120             $d->setDataType('string'); 
    121             $d->setMaxLength('100'); 
    122             $d->setMinLength(null); 
    123             $d->setRequired(true); 
    124  
    125             $c->addData($d); 
    126  
    127             $d = new Data(); 
    128             $d->setName('number_of_messages'); 
    129             $d->setValue($dynamicContacts[0]['number_of_messages']); 
    130             $d->setPrompt('Quantidade de mensagens enviadas'); 
    131             $d->setDataType('integer'); 
    132             $d->setMaxLength('100'); 
    133             $d->setMinLength(null); 
    134             $d->setRequired(false); 
    135  
    136             $c->addData($d); 
    137  
    138  
    139             $l = new Link(); 
    140  
    141             $l->setHref(''); 
    142             $l->setRel('delete'); 
    143             $l->setAlt('Remover'); 
    144             $l->setPrompt('Remover'); 
    145             $l->setRender('link'); 
    146  
    147             $c->addLink($l); 
    148  
    149             $l = new Link(); 
    150             $l->setHref(''); 
    151             $l->setRel('put'); 
    152             $l->setAlt('Atualizar'); 
    153             $l->setPrompt('Atualizar'); 
    154             $l->setRender('link'); 
    155  
    156             $c->addLink($l); 
     22    function get($request, $id) { 
     23 
     24        $this->secured(); 
     25 
     26        $response = new Response($request); 
     27        $response->addHeader('Content-type', 'aplication/json'); 
     28        $response->code = Response::OK; 
     29 
     30        $h = new Hypermedia(); 
     31        $c = new Collection($request->resources, 'DynamicContactResource', $id); 
     32 
     33        try { 
     34            $dynamicContact = Controller::read( 
     35                            array('concept' => 'dynamicContact'), false, array('filter' => array('AND', array('=', 'owner', Config::me("uidNumber")), array('=', 'id', $id))) 
     36            ); 
     37 
     38            //Se nao foi encontrado contatos na consulta 
     39            if (!$dynamicContact) { 
     40                $this->createException($request, $response, Response::NOTFOUND, 'Bad request', 'Dynamic Contact not found.'); 
     41                return $response; 
     42            } 
     43             
     44            //Normaliza dado 
     45            if(is_array($dynamicContact)) 
     46                $dynamicContact = $dynamicContact[0]; 
     47 
     48 
     49            $t = new Template(); 
     50            $d = new Data(); 
     51 
     52            $d->setName('name'); 
     53            $d->setValue(null); 
     54            $d->setPrompt('Nome do Contato Recente'); 
     55            $d->setDataType('string'); 
     56            $d->setMaxLength(100); 
     57            $d->setMinLength(null); 
     58            $d->setRequired(true); 
     59 
     60            $t->addData($d); 
     61 
     62            $d = new Data(); 
     63            $d->setName('mail'); 
     64            $d->setValue(null); 
     65            $d->setPrompt('Email do Contato Recente'); 
     66            $d->setDataType('string'); 
     67            $d->setMaxLength(100); 
     68            $d->setMinLength(null); 
     69            $d->setRequired(true); 
     70 
     71            $t->addData($d); 
     72 
     73            $d = new Data(); 
     74            $d->setName('number_of_messages'); 
     75            $d->setValue(null); 
     76            $d->setPrompt('Quantidade de mensagens enviadas'); 
     77            $d->setDataType('integer'); 
     78            $d->setMaxLength(100); 
     79            $d->setMinLength(null); 
     80            $d->setRequired(false); 
     81 
     82            $t->addData($d); 
     83 
     84            $c->setTemplate($t); 
     85 
     86            $d = new Data(); 
     87            $d->setName('id'); 
     88            $d->setValue($dynamicContact['id']); 
     89            $d->setPrompt('Identificador do Contato Recente'); 
     90            $d->setDataType('integer'); 
     91            $d->setMaxLength(null); 
     92            $d->setMinLength(null); 
     93            $d->setRequired(true); 
     94 
     95            $c->addData($d); 
     96 
     97            $d = new Data(); 
     98 
     99            $d->setName('name'); 
     100            $d->setValue($dynamicContact['name']); 
     101            $d->setPrompt('Nome do Contato Recente'); 
     102            $d->setDataType('string'); 
     103            $d->setMaxLength('100'); 
     104            $d->setMinLength(null); 
     105            $d->setRequired(true); 
     106 
     107            $c->addData($d); 
     108 
     109            $d = new Data(); 
     110            $d->setName('mail'); 
     111            $d->setValue($dynamicContact['mail']); 
     112            $d->setPrompt('Email do Contato Recente'); 
     113            $d->setDataType('string'); 
     114            $d->setMaxLength('100'); 
     115            $d->setMinLength(null); 
     116            $d->setRequired(true); 
     117 
     118            $c->addData($d); 
     119 
     120            $d = new Data(); 
     121            $d->setName('number_of_messages'); 
     122            $d->setValue($dynamicContact['number_of_messages']); 
     123            $d->setPrompt('Quantidade de mensagens enviadas'); 
     124            $d->setDataType('integer'); 
     125            $d->setMaxLength('100'); 
     126            $d->setMinLength(null); 
     127            $d->setRequired(false); 
     128 
     129            $c->addData($d); 
     130 
     131 
     132            $l = new Link(); 
     133 
     134            $l->setHref(''); 
     135            $l->setRel('delete'); 
     136            $l->setAlt('Remover'); 
     137            $l->setPrompt('Remover'); 
     138            $l->setRender('link'); 
     139 
     140            $c->addLink($l); 
     141 
     142            $l = new Link(); 
     143            $l->setHref(''); 
     144            $l->setRel('put'); 
     145            $l->setAlt('Atualizar'); 
     146            $l->setPrompt('Atualizar'); 
     147            $l->setRender('link'); 
     148 
     149            $c->addLink($l); 
    157150 
    158151            $h->setCollection($c); 
    159   
    160  
    161         }catch (Exception $ex){ 
    162                 $error = new Error(); 
    163                 $error->setCode(Response::INTERNALSERVERERROR); 
    164                 $error->setTitle('Internal Server Error'); 
    165                 $error->setDescription($ex); 
    166  
    167                 $c->setError($error); 
    168                 $h->setCollection($c); 
    169  
    170                 $response->code = Response::INTERNALSERVERERROR; 
    171                 $response->body = $h->getHypermedia($request->accept[10][0]); 
    172                 return $response; 
    173         } 
    174  
    175         $response->body = $h->getHypermedia($request->accept[10][0]); 
    176         return $response; 
    177      }    
     152        } catch (Exception $ex) { 
     153            $this->createException($request, $response, Response::INTERNALSERVERERROR, 'Internal Server Error', 'Internal Server Error'); 
     154            return $response; 
     155        } 
     156 
     157        $response->body = $h->getHypermedia($request->accept[10][0]); 
     158        return $response; 
     159    } 
    178160 
    179161    /** 
    … …  
    187169     * @access     public 
    188170     * */ 
    189      function put($request, $id){ 
    190 $post = $request->dataDecoded; 
    191  
    192         if(count($post) == 0){ 
    193                 $response = new Response($request); 
    194                 $response->code = Response::INTERNALSERVERERROR; 
    195                 return $response; 
    196         } 
    197  
    198         //recupera os atributos definidos no conceito 'user' 
    199         $map = Config::get('dynamicContact', 'PostgreSQL.mapping'); 
    200  
    201         $params = array(); 
    202         foreach($post as $key => $value){ 
    203  
    204                 if( !isset( $map[ $key ] ) || $key == 'id' || $key == 'timestamp' || $key == 'number_of_messages' ){ 
    205                         continue; 
    206                 } 
    207                 $params[$key] = $value; 
    208         } 
    209  
    210         if(count($params) == 0){ 
    211                 $response = new Response($request); 
    212                 $response->code = Response::INTERNALSERVERERROR; 
    213                 return $response; 
    214         } 
    215  
    216         //completar os atributos 
    217         $params['owner']                = Config::me("uidNumber"); 
    218         $params['timestamp']            = time(); 
    219         $params['id']                   = $id; 
    220  
    221  
    222         $response = new Response($request); 
    223 //      $response->addHeader('Content-type', 'aplication/json'); 
    224 //        $response->code = Response::NOCONTENT; 
    225  
    226         try{ 
    227  
    228 //                      $this->secured(); 
    229  
    230                 $dynamicContact = Controller::read( 
    231                                                 array( 'concept' => 'dynamicContact' ), 
    232                                                 false, 
    233                                                 array( 'filter' => array(  
    234                                                                         'AND',  
    235                                                                         array('=', 'owner',  Config::me("uidNumber") ),  
    236                                                                         array('=', 'id', $id) )  )  
    237                 ); 
    238  
     171    function put($request, $id) { 
     172         
     173        $this->secured(); 
     174 
     175        $post = $request->dataDecoded; 
     176        $response = new Response($request); 
     177 
     178        if (count($post) == 0){ 
     179            $this->createException($request, $response, Response::BADREQUEST, 'Bad request', 'Invalid template data'); 
     180            return $response; 
     181        } 
     182 
     183        //recupera os atributos definidos no conceito 'user' 
     184        $map = Config::get('dynamicContact', 'PostgreSQL.mapping'); 
     185 
     186        $params = array(); 
     187        foreach ($post as $key => $value) { 
     188 
     189            if (!isset($map[$key]) || $key == 'id' || $key == 'timestamp' || $key == 'number_of_messages') { 
     190                continue; 
     191            } 
     192            $params[$key] = $value; 
     193        } 
     194 
     195        if (count($params) == 0) { 
     196            $this->createException($request, $response, Response::BADREQUEST, 'Bad request', 'Invalid template data'); 
     197            return $response; 
     198        } 
     199 
     200        //completar os atributos 
     201        $params['owner'] = Config::me("uidNumber"); 
     202        $params['timestamp'] = time(); 
     203        $params['id'] = $id; 
     204 
     205        $response->addHeader('Content-type', 'aplication/json'); 
     206        $response->code = Response::NOCONTENT; 
     207 
     208        try { 
     209 
     210            $dynamicContact = Controller::read( 
     211                            array('concept' => 'dynamicContact'), false, array('filter' => array( 
     212                            'AND', 
     213                            array('=', 'owner', Config::me("uidNumber")), 
     214                            array('=', 'id', $id))) 
     215            ); 
     216 
     217 
     218            //Se existe o recurso 
     219            if ($dynamicContact) { 
     220                //Normaliza o recurso 
     221                if(is_array($dynamicContact)) 
     222                    $dynamicContact = $dynamicContact[0]; 
    239223                 
    240                 //Se existe o recurso 
    241                 if($dynamicContact){ 
    242                                         $params['number_of_messages'] = $dynamicContact[0]['number_of_messages'] + 1; 
    243                                         $dynamicContact = Controller::update( 
    244                                                         array('concept' => 'dynamicContact', 
    245                                                                                                                 'id'=>$id), 
    246                                                         $params 
    247                     ); 
    248  
    249                     if(!$dynamicContact){ 
    250                         throw new Exception(Controller::service('PostgreSQL')->error); 
    251                     } 
    252  
    253                 } 
    254                 else{ 
    255                                         $params['number_of_messages']   = '1'; 
    256                     $idDynamicContact = Controller::create( 
    257                                                         array('concept' => 'dynamicContact'), 
    258                                                         $params 
    259                     ); 
    260  
    261                     if(!$idDynamicContact){ 
    262                         throw new Exception(Controller::service('PostgreSQL')->error); 
    263                     } 
    264  
    265                 } 
    266  
    267         }catch (Exception $ex){ 
    268                 $response->code = Response::INTERNALSERVERERROR; 
    269                 return $response; 
    270         } 
    271  
    272         return $response; 
    273  
    274      }    
     224                $params['number_of_messages'] = $dynamicContact['number_of_messages'] + 1;  
     225 
     226                $dynamicContact = Controller::update(array('concept' => 'dynamicContact', 'id' => $id), $params); 
     227 
     228                if (!$dynamicContact) { 
     229                    $this->createException($request, $response, Response::INTERNALSERVERERROR, 'Internal Server Error', Controller::service('PostgreSQL')->error); 
     230                    return $response; 
     231                } 
     232            } else { 
     233                /* 
     234                $idDynamicContact = Controller::create( array('concept' => 'dynamicContact'), $params); 
     235                */ 
     236                //if (!$idDynamicContact) { 
     237                    $this->createException($request, $response, Response::NOTFOUND, 'Bad request', 'Invalid data'); 
     238                    return $response; 
     239                //} 
     240            } 
     241        } catch (Exception $ex) { 
     242            $this->createException($request, $response, Response::INTERNALSERVERERROR, 'Internal Server Error', 'Internal Server Error'); 
     243            return $response; 
     244        } 
     245        $response->body = json_encode(null); 
     246        return $response; 
     247    } 
    275248 
    276249    /** 
    … …  
    283256     * @access     public 
    284257     * */ 
    285      function delete($request, $id){ 
     258    function delete($request, $id) { 
     259 
     260        $this->secured(); 
    286261 
    287262        $response = new Response($request); 
    288 //      $response->addHeader('Content-type', 'aplication/json'); 
     263        $response->addHeader('Content-type', 'aplication/json'); 
    289264        $response->code = Response::NOCONTENT; 
    290265 
    291         try{ 
    292                 //Verifica se o recurso existe 
    293                 $responseGET = $this->get($request, $id); 
    294                 $code = $responseGET->code; 
    295  
    296                 //Se existe o recurso 
    297                 if($code == Response::OK){ 
    298  
    299 //                      $this->secured(); 
    300  
    301                         $delete = Controller::delete(array('concept' => 'dynamicContact'), false, array('filter' => array('=', 'id', $id))); 
    302  
    303                         if(!$delete){ 
    304                                 throw new Exception(Controller::service('PostgreSQL')->error); 
    305                         } 
     266        try { 
     267            //Verifica se o recurso existe 
     268            $dinamicContact = Controller::read(array('concept' => 'dynamicContact', 'id' => $id)); 
     269 
     270            //Se existe o recurso 
     271            if ($dinamicContact) { 
     272 
     273                $delete = Controller::delete(array('concept' => 'dynamicContact', 'id' => $id)); 
     274 
     275                if (!$delete) { 
     276                    $this->createException($request, $response, Response::INTERNALSERVERERROR, 'Internal Server Error', Controller::service('PostgreSQL')->error); 
     277                    return $response; 
    306278                } 
    307                 else{ 
    308                         $response->code = Response::NOTFOUND; 
    309                 } 
    310  
    311         }catch (Exception $ex){ 
    312                 $response->code = Response::INTERNALSERVERERROR; 
    313                 return $response; 
    314         } 
    315  
    316 $response->body = json_encode(array('ABC'=>'123')); 
    317  
    318         return $response; 
    319      } 
     279            } else { 
     280                $this->createException($request, $response, Response::NOTFOUND, 'Bad request', 'Invalid data'); 
     281                return $response; 
     282            } 
     283        } catch (Exception $ex) { 
     284            $this->createException($request, $response, Response::INTERNALSERVERERROR, 'Internal Server Error', 'Internal Server Error'); 
     285            return $response; 
     286        } 
     287 
     288        $response->body = json_encode(null); 
     289        return $response; 
     290    } 
     291     
     292     private function createException($request, &$response, $code, $title, $description) { 
     293        $response->code = $code; 
     294          
     295        $h = new Hypermedia(); 
     296        $c = new Collection($request->resources, 'DynamicContactResource'); 
     297        $e = new Error(); 
     298 
     299        $e->setCode($code); 
     300        $e->setTitle($title); 
     301        $e->setDescription($description); 
     302         
     303        $c->setError($e); 
     304        $h->setCollection($c); 
     305 
     306        $response->body = $h->getHypermedia($request->accept[10][0]); 
     307    } 
    320308 
    321309} 
     310 
    322311?> 

  • sandbox/2.4.1-3/prototype/rest/catalog/DynamicContactsResource.php

    r6512 r6523  
    11<?php 
    22 
    3 if( !defined( 'ROOTPATH' ) ) 
    4     define( 'ROOTPATH', dirname(__FILE__).'/..' ); 
    5  
    6 require_once(ROOTPATH.'/rest/hypermedia/hypermedia.php'); 
     3if (!defined('ROOTPATH')) 
     4    define('ROOTPATH', dirname(__FILE__) . '/..'); 
     5 
     6require_once(ROOTPATH . '/rest/hypermedia/hypermedia.php'); 
    77 
    88use prototype\api\Config as Config; 
    … …  
    2222    function get($request) { 
    2323 
     24        $this->secured(); 
     25 
    2426        $response = new Response($request); 
    2527        $response->addHeader('Content-type', 'aplication/json'); 
    … …  
    3032 
    3133        try { 
    32 //          $this->secured(); 
    33  
    34             $dynamicContacts = Controller::find(  
    35                                                 array( 'concept' => 'dynamicContact' ),  
    36                                                 false,  
    37                                                 array( 'filter' => array( '=', 'owner',  Config::me("uidNumber") ),  
    38                                                 'order' => array('number_of_messages','name','mail'),  
    39                                                 'orderDesc' => array(true, false, false) )  
     34 
     35            $dynamicContacts = Controller::find( 
     36                            array('concept' => 'dynamicContact'), false, array('filter' => array('=', 'owner', Config::me("uidNumber")), 
     37                        'order' => array('number_of_messages', 'name', 'mail'), 
     38                        'orderDesc' => array(true, false, false)) 
    4039            ); 
    4140 
    4241            //Se nao foi encontrado contatos na consulta 
    43             if($dynamicContacts===false){ 
    44                 $error = new Error(); 
    45                 $error->setCode(Response::NOTFOUND); 
    46                 $error->setTitle('Dynamic Contacts not found'); 
    47                 $error->setDescription('Dynamic Contacts not found.'); 
    48  
    49                 $c->setError($error); 
    50                 $h->setCollection($c); 
    51  
    52                 $response->code = Response::NOTFOUND; 
    53                 $response->body = $h->getHypermedia($request->accept[10][0]); 
     42            if (!$dynamicContacts) { 
     43                $this->createException($request, $response, Response::NOTFOUND, 'Bad request', 'Dynamic Contact not found.'); 
    5444                return $response; 
    5545            } 
    5646 
    57             foreach($dynamicContacts as $value){ 
    58                 $d = new Data(); 
    59                 $i = new Item($request->resources, 'DynamicContactsResource', $value['id']); 
     47            foreach ($dynamicContacts as $value) { 
     48                $d = new Data(); 
     49                $i = new Item($request->resources, 'DynamicContactsResource', $value['id']); 
    6050 
    6151                $d->setName('name'); 
    62                 $d->setValue($value['name']); 
    63                 $d->setPrompt('Nome do Contato Recente'); 
    64                 $d->setDataType('string'); 
    65                 $d->setMaxLength('100'); 
    66                 $d->setMinLength(null); 
    67                 $d->setRequired(true); 
    68  
    69                 $i->addData($d); 
    70  
    71                 $d = new Data(); 
    72                 $d->setName('mail'); 
    73                 $d->setValue($value['mail']); 
    74                 $d->setPrompt('Email do Contato Recente'); 
    75                 $d->setDataType('string'); 
    76                 $d->setMaxLength('100'); 
    77                 $d->setMinLength(null); 
    78                 $d->setRequired(true); 
    79  
    80                 $i->addData($d); 
    81  
    82                 $d = new Data(); 
    83                 $d->setName('number_of_messages'); 
    84                 $d->setValue($value['number_of_messages']); 
    85                 $d->setPrompt('Quantidade de mensagens enviadas'); 
    86                 $d->setDataType('integer'); 
    87                 $d->setMaxLength('100'); 
    88                 $d->setMinLength(null); 
    89                 $d->setRequired(false); 
    90  
    91                 $i->addData($d); 
    92                                  
    93                                 $d = new Data(); 
    94                 $d->setName('id'); 
    95                 $d->setValue($value['id']); 
    96                 $d->setPrompt('Id do contato dinamico'); 
    97                 $d->setDataType('integer'); 
    98                 $d->setMaxLength('100'); 
    99                 $d->setMinLength(null); 
    100                 $d->setRequired(false); 
    101  
    102                 $i->addData($d); 
    103  
    104                 $l = new Link(); 
    105  
    106                 $l->setHref(''); 
    107                 $l->setRel('delete'); 
    108                 $l->setAlt('Remover'); 
    109                 $l->setPrompt('Remover'); 
    110                 $l->setRender('link'); 
    111  
    112                 $i->addLink($l); 
    113  
    114                 $l = new Link(); 
    115                 $l->setHref(''); 
    116                 $l->setRel('put'); 
    117                 $l->setAlt('Atualizar'); 
    118                 $l->setPrompt('Atualizar'); 
    119                 $l->setRender('link'); 
    120  
    121                 $i->addLink($l); 
    122  
    123                 $l = new Link(); 
    124                 $l->setHref('/dynamiccontact/'.$value['id']); 
    125                 $l->setRel('get'); 
    126                 $l->setAlt('Buscar'); 
    127                 $l->setPrompt('Buscar'); 
    128                 $l->setRender('link'); 
    129  
    130                 $i->addLink($l); 
    131                 $c->addItem($i); 
    132             } 
    133  
    134             $t = new Template(); 
    135             $d = new Data(); 
    136  
    137             $d->setName('name'); 
    138             $d->setValue(null); 
    139             $d->setPrompt('Nome do Contato Recente'); 
    140             $d->setDataType('string'); 
    141             $d->setMaxLength(100); 
    142             $d->setMinLength(null); 
    143             $d->setRequired(true); 
    144  
    145             $t->addData($d); 
    146  
    147             $d = new Data(); 
    148             $d->setName('mail'); 
    149             $d->setValue(null); 
    150             $d->setPrompt('Email do Contato Recente'); 
    151             $d->setDataType('string'); 
    152             $d->setMaxLength(100); 
    153             $d->setMinLength(null); 
    154             $d->setRequired(true); 
    155  
    156             $t->addData($d); 
    157  
    158             $d = new Data(); 
    159             $d->setName('number_of_messages'); 
    160             $d->setValue(null); 
    161             $d->setPrompt('Quantidade de mensagens enviadas'); 
    162             $d->setDataType('integer'); 
    163             $d->setMaxLength(100); 
    164             $d->setMinLength(null); 
    165             $d->setRequired(false); 
    166  
    167             $t->addData($d); 
    168  
    169             $c->setTemplate($t); 
    170  
    171             $h->setCollection($c); 
    172  
    173         }catch (Exception $ex){ 
    174                 $error = new Error(); 
    175                 $error->setCode(Response::INTERNALSERVERERROR); 
    176                 $error->setTitle('Internal Server Error'); 
    177                 $error->setDescription($ex); 
    178  
    179                 $c->setError($error); 
    180                 $h->setCollection($c); 
    181  
    182                 $response->code = Response::INTERNALSERVERERROR; 
    183                 $response->body = $h->getHypermedia($request->accept[10][0]); 
    184                 return $response; 
     52                $d->setValue($value['name']); 
     53                $d->setPrompt('Nome do Contato Recente'); 
     54                $d->setDataType('string'); 
     55                $d->setMaxLength('100'); 
     56                $d->setMinLength(null); 
     57                $d->setRequired(true); 
     58 
     59                $i->addData($d); 
     60 
     61                $d = new Data(); 
     62                $d->setName('mail'); 
     63                $d->setValue($value['mail']); 
     64                $d->setPrompt('Email do Contato Recente'); 
     65                $d->setDataType('string'); 
     66                $d->setMaxLength('100'); 
     67                $d->setMinLength(null); 
     68                $d->setRequired(true); 
     69 
     70                $i->addData($d); 
     71 
     72                $d = new Data(); 
     73                $d->setName('number_of_messages'); 
     74                $d->setValue($value['number_of_messages']); 
     75                $d->setPrompt('Quantidade de mensagens enviadas'); 
     76                $d->setDataType('integer'); 
     77                $d->setMaxLength('100'); 
     78                $d->setMinLength(null); 
     79                $d->setRequired(false); 
     80 
     81                $i->addData($d); 
     82 
     83                $d = new Data(); 
     84                $d->setName('id'); 
     85                $d->setValue($value['id']); 
     86                $d->setPrompt('Id do contato dinamico'); 
     87                $d->setDataType('integer'); 
     88                $d->setMaxLength('100'); 
     89                $d->setMinLength(null); 
     90                $d->setRequired(false); 
     91 
     92                $i->addData($d); 
     93 
     94                $l = new Link(); 
     95 
     96                $l->setHref(''); 
     97                $l->setRel('delete'); 
     98                $l->setAlt('Remover'); 
     99                $l->setPrompt('Remover'); 
     100                $l->setRender('link'); 
     101 
     102                $i->addLink($l); 
     103 
     104                $l = new Link(); 
     105                $l->setHref(''); 
     106                $l->setRel('put'); 
     107                $l->setAlt('Atualizar'); 
     108                $l->setPrompt('Atualizar'); 
     109                $l->setRender('link'); 
     110 
     111                $i->addLink($l); 
     112 
     113                $l = new Link(); 
     114                $l->setHref('/dynamiccontact/' . $value['id']); 
     115                $l->setRel('get'); 
     116                $l->setAlt('Buscar'); 
     117                $l->setPrompt('Buscar'); 
     118                $l->setRender('link'); 
     119 
     120                $i->addLink($l); 
     121                $c->addItem($i); 
     122            } 
     123 
     124            $t = new Template(); 
     125            $d = new Data(); 
     126 
     127            $d->setName('name'); 
     128            $d->setValue(null); 
     129            $d->setPrompt('Nome do Contato Recente'); 
     130            $d->setDataType('string'); 
     131            $d->setMaxLength(100); 
     132            $d->setMinLength(null); 
     133            $d->setRequired(false); 
     134 
     135            $t->addData($d); 
     136 
     137            $d = new Data(); 
     138            $d->setName('mail'); 
     139            $d->setValue(null); 
     140            $d->setPrompt('Email do Contato Recente'); 
     141            $d->setDataType('string'); 
     142            $d->setMaxLength(100); 
     143            $d->setMinLength(null); 
     144            $d->setRequired(true); 
     145 
     146            $t->addData($d); 
     147 
     148            $d = new Data(); 
     149            $d->setName('number_of_messages'); 
     150            $d->setValue(null); 
     151            $d->setPrompt('Quantidade de mensagens enviadas'); 
     152            $d->setDataType('integer'); 
     153            $d->setMaxLength(100); 
     154            $d->setMinLength(null); 
     155            $d->setRequired(false); 
     156 
     157            $t->addData($d); 
     158 
     159            $c->setTemplate($t); 
     160 
     161            $h->setCollection($c); 
     162        } catch (Exception $ex) { 
     163            $this->createException($request, $response, Response::INTERNALSERVERERROR, 'Internal Server Error', $ex); 
     164            return $response; 
    185165        } 
    186166 
    … …  
    199179     * @access     public 
    200180     * */ 
    201      function post($request){ 
    202  
    203         if(count($_POST) == 0){ 
    204                 $response = new Response($request); 
    205                 $response->code = Response::INTERNALSERVERERROR; 
    206                 return $response; 
     181    function post($request) { 
     182 
     183        $this->secured(); 
     184         
     185        if (count($_POST) == 0) { 
     186            $response = new Response($request); 
     187            $response->code = Response::INTERNALSERVERERROR; 
     188            return $response; 
    207189        } 
    208190 
    … …  
    211193 
    212194        $params = array(); 
    213         foreach($_POST as $key => $value){ 
    214  
    215                 if( !isset( $map[ $key ] ) || $key == 'id' || $key == 'timestamp' || $key == 'number_of_messages' ){ 
    216                         continue; 
    217                 } 
    218                 $params[$key] = $value; 
    219         } 
    220  
    221         if(count($params) == 0){ 
    222                 $response = new Response($request); 
    223                 $response->code = Response::INTERNALSERVERERROR; 
    224                 return $response; 
    225         } 
    226  
    227  
    228         $response = new Response($request); 
    229 //      $response->addHeader('Content-type', 'aplication/json'); 
    230         $response->code = Response::CREATED; 
    231  
    232          
     195        foreach ($_POST as $key => $value) { 
     196 
     197            if (!isset($map[$key]) || $key == 'id' || $key == 'timestamp' || $key == 'number_of_messages') { 
     198                continue; 
     199            } 
     200            $params[$key] = $value; 
     201        } 
     202 
     203        if (count($params) == 0) { 
     204            $response = new Response($request); 
     205            $response->code = Response::INTERNALSERVERERROR; 
     206            return $response; 
     207        } 
     208 
     209 
     210        $response = new Response($request); 
     211        $response->addHeader('Content-type', 'aplication/json'); 
     212        $response->code = Response::CREATED; 
     213 
     214 
    233215        //completar os atributos 
    234         $params['owner']                = Config::me("uidNumber"); 
    235         $params['number_of_messages']   = '1'; 
    236         $params['timestamp']            = time(); 
    237  
    238  
    239         try{ 
    240  
    241 //                      $this->secured(); 
    242       
    243                     $idDynamicContact = Controller::create( 
    244                                                         array('concept' => 'dynamicContact'),  
    245                                                         $params 
    246                     ); 
    247  
    248                     if(!$idDynamicContact){ 
    249                         throw new Exception(Controller::service('PostgreSQL')->error); 
    250                     } 
    251  
    252         }catch (Exception $ex){ 
    253                 $response->code = Response::INTERNALSERVERERROR; 
    254                 return $response; 
    255         } 
    256  
    257 $response->body = json_encode(array('abc'=>'123')); 
    258  
    259         return $response; 
    260      } 
    261  
     216        $params['owner'] = Config::me("uidNumber"); 
     217        $params['number_of_messages'] = '1'; 
     218        $params['timestamp'] = time(); 
     219 
     220 
     221        try { 
     222            $idDynamicContact = Controller::create( 
     223                            array('concept' => 'dynamicContact'), $params 
     224            ); 
     225 
     226            if (!$idDynamicContact) { 
     227                throw new Exception(Controller::service('PostgreSQL')->error); 
     228            } 
     229        } catch (Exception $ex) { 
     230            $response->code = Response::INTERNALSERVERERROR; 
     231            return $response; 
     232        } 
     233 
     234        $response->body = json_encode(null); 
     235 
     236        return $response; 
     237    } 
     238 
     239    private function createException($request, &$response, $code, $title, $description) { 
     240        $response->code = $code; 
     241 
     242        $h = new Hypermedia(); 
     243        $c = new Collection($request->resources, 'DynamicContactResource'); 
     244        $e = new Error(); 
     245 
     246        $e->setCode($code); 
     247        $e->setTitle($title); 
     248        $e->setDescription($description); 
     249 
     250        $c->setError($e); 
     251        $h->setCollection($c); 
     252 
     253        $response->body = $h->getHypermedia($request->accept[10][0]); 
     254    } 
    262255 
    263256} 
     257 
    264258?> 

  • sandbox/2.4.1-3/prototype/rest/hypermedia/collection.php

    r6437 r6523  
    2929    public $type; 
    3030    public $data; 
    31         public $links; 
     31    public $links; 
    3232 
    33     function __construct($config, $className) { 
     33    function __construct($config, $className, $id = null) { 
    3434        foreach ($config as $key => $value) { 
    3535            if ($value['class'] == $className) { 
    36                 $uri = $key; 
     36                $uri = ($id ? (preg_replace('/\/[:][a-zA-Z-0-9]+/', '', $key).'/'.$id ) : $key); 
    3737                break; 
    3838            } 

  • sandbox/2.4.1-3/prototype/rest/hypermedia/hypermedia.php

    r6395 r6523  
    3030        } 
    3131    } 
    32  
    33 // functions adopted from http://www.sean-barton.co.uk/2009/03/turning-an-array-or-object-into-xml-using-php/ 
    3432 
    3533    function generateValidXmlFromObj(stdClass $obj, $node_block = 'nodes', $node_name = 'node') { 
Note: See TracChangeset for help on using the changeset viewer.