Lançado Adianti Framework 7.6!
Clique aqui para saber mais
menu
Adianti Framework
A base robusta e open-source para criar sistemas com agilidade e código limpo.
Adianti Reports & BI
Dashboards analíticos e Relatórios para Empresas e Produtores de Software.
Mentoring
Auxilio de especialista para o desenvolvimento decolar.
Treinamento
Capacitação oficial com profissionais Adianti.
Outsourcing
Desenvolvimento de aplicações sob demanda.

Adianti Solutions

API

 Adianti, Framework, PHP, MVC, Active record, Front controller, IDE, RAD, Web, multiplataforma, geração de código, desenvolvimento rápido, relatórios, formulários, listagens, datagrids, gráficos, banco de dados, padrões de projeto, design patterns API do Adianti Framework.
API Docs
code
Selecione a classe

Source for file AdiantiRecordService.php

Documentation is available at AdiantiRecordService.php

  1. <?php
  2. namespace Adianti\Service;
  3.  
  4. use Adianti\Database\TTransaction;
  5. use Adianti\Database\TRepository;
  6. use Adianti\Database\TCriteria;
  7. use Adianti\Database\TFilter;
  8.  
  9. /**
  10.  * Record rest service
  11.  *
  12.  * @version    7.4
  13.  * @package    service
  14.  * @author     Pablo Dall'Oglio
  15.  * @copyright  Copyright (c) 2006 Adianti Solutions Ltd. (http://www.adianti.com.br)
  16.  * @license    http://www.adianti.com.br/framework-license
  17.  */
  18. class AdiantiRecordService
  19. {
  20.     /**
  21.      * Find a Active Record and returns it
  22.      * @return The Active Record itself as array
  23.      * @param $param HTTP parameter
  24.      */
  25.     public function load($param)
  26.     {
  27.         $database     = static::DATABASE;
  28.         $activeRecord = static::ACTIVE_RECORD;
  29.         
  30.         TTransaction::open($database);
  31.         
  32.         $object = new $activeRecord($param['id'], FALSE);
  33.         
  34.         TTransaction::close();
  35.         $attributes = defined('static::ATTRIBUTES') ? static::ATTRIBUTES : null;
  36.         return $object->toArray( $attributes );
  37.     }
  38.     
  39.     /**
  40.      * Delete an Active Record object from the database
  41.      * @param [$id]     HTTP parameter
  42.      */
  43.     public function delete($param)
  44.     {
  45.         $database     = static::DATABASE;
  46.         $activeRecord = static::ACTIVE_RECORD;
  47.         
  48.         TTransaction::open($database);
  49.         
  50.         $object = new $activeRecord($param['id']);
  51.         $object->delete();
  52.         
  53.         TTransaction::close();
  54.         return;
  55.     }
  56.     
  57.     /**
  58.      * Store the objects into the database
  59.      * @param $param HTTP parameter
  60.      */
  61.     public function store($param)
  62.     {
  63.         $database     = static::DATABASE;
  64.         $activeRecord = static::ACTIVE_RECORD;
  65.         
  66.         TTransaction::open($database);
  67.         
  68.         $object = new $activeRecord;
  69.         $pk = $object->getPrimaryKey();
  70.         $param['data'][$pk] = $param['data']['id'] ?? NULL;
  71.         $object->fromArray( (array) $param['data']);
  72.         $object->store();
  73.         
  74.         TTransaction::close();
  75.         return $object->toArray();
  76.     }
  77.     
  78.     /**
  79.      * List the Active Records by the filter
  80.      * @return The Active Record list as array
  81.      * @param $param HTTP parameter
  82.      */
  83.     public function loadAll($param)
  84.     {
  85.         $database     = static::DATABASE;
  86.         $activeRecord = static::ACTIVE_RECORD;
  87.         
  88.         TTransaction::open($database);
  89.         
  90.         $criteria = new TCriteria;
  91.         if (isset($param['offset']))
  92.         {
  93.             $criteria->setProperty('offset', $param['offset']);
  94.         }
  95.         if (isset($param['limit']))
  96.         {
  97.             $criteria->setProperty('limit', $param['limit']);
  98.         }
  99.         if (isset($param['order']))
  100.         {
  101.             $criteria->setProperty('order', $param['order']);
  102.         }
  103.         if (isset($param['direction']))
  104.         {
  105.             $criteria->setProperty('direction', $param['direction']);
  106.         }
  107.         if (isset($param['filters']))
  108.         {
  109.             foreach ($param['filters'] as $filter)
  110.             {
  111.                 $criteria->add(new TFilter($filter[0], $filter[1], $filter[2]));
  112.             }
  113.         }
  114.         
  115.         $repository = new TRepository($activeRecord);
  116.         $objects = $repository->load($criteria, FALSE);
  117.         $attributes = defined('static::ATTRIBUTES') ? static::ATTRIBUTES : null;
  118.         
  119.         $return = [];
  120.         if ($objects)
  121.         {
  122.             foreach ($objects as $object)
  123.             {
  124.                 $return[] = $object->toArray( $attributes );
  125.             }
  126.         }
  127.         TTransaction::close();
  128.         return $return;
  129.     }
  130.     
  131.     /**
  132.      * Delete the Active Records by the filter
  133.      * @return The result of operation
  134.      * @param $param HTTP parameter
  135.      */
  136.     public function deleteAll($param)
  137.     {
  138.         $database     = static::DATABASE;
  139.         $activeRecord = static::ACTIVE_RECORD;
  140.         
  141.         TTransaction::open($database);
  142.         
  143.         $criteria = new TCriteria;
  144.         if (isset($param['filters']))
  145.         {
  146.             foreach ($param['filters'] as $filter)
  147.             {
  148.                 $criteria->add(new TFilter($filter[0], $filter[1], $filter[2]));
  149.             }
  150.         }
  151.         
  152.         $repository = new TRepository($activeRecord);
  153.         $return = $repository->delete($criteria);
  154.         TTransaction::close();
  155.         return $return;
  156.     }
  157.  
  158.     /**
  159.      * Find the count Records by the filter
  160.      * @return The Active Record list as array
  161.      * @param $param HTTP parameter
  162.      */
  163.     public function countAll($param)
  164.     {
  165.         $database     = static::DATABASE;
  166.         $activeRecord = static::ACTIVE_RECORD;
  167.  
  168.         TTransaction::open($database);
  169.  
  170.         $criteria = new TCriteria;
  171.         if (isset($param['offset']))
  172.         {
  173.             $criteria->setProperty('offset', $param['offset']);
  174.         }
  175.         if (isset($param['limit']))
  176.         {
  177.             $criteria->setProperty('limit', $param['limit']);
  178.         }
  179.         if (isset($param['order']))
  180.         {
  181.             $criteria->setProperty('order', $param['order']);
  182.         }
  183.         if (isset($param['direction']))
  184.         {
  185.             $criteria->setProperty('direction', $param['direction']);
  186.         }
  187.         if (isset($param['filters']))
  188.         {
  189.             foreach ($param['filters'] as $filter)
  190.             {
  191.                 $criteria->add(new TFilter($filter[0], $filter[1], $filter[2]));
  192.             }
  193.         }
  194.  
  195.         $repository = new TRepository($activeRecord);
  196.         $count = $repository->count($criteria, FALSE);
  197.  
  198.         TTransaction::close();
  199.         return $count;
  200.     }
  201.     
  202.     /**
  203.      * Handle HTTP Request and dispatch
  204.      * @param $param HTTP POST and php input vars
  205.      */
  206.     public function handle($param)
  207.     {
  208.         $method = strtoupper($_SERVER['REQUEST_METHOD']);
  209.         
  210.         unset($param['class']);
  211.         unset($param['method']);
  212.         $param['data'] = $param;
  213.         
  214.         switch( $method )
  215.         {
  216.             case 'GET':
  217.                 if (!empty($param['id']))
  218.                 {
  219.                     return self::load($param);
  220.                 }
  221.                 else
  222.                 {
  223.                     return self::loadAll($param);
  224.                 }
  225.                 break;
  226.             case 'POST':
  227.                 return self::store($param);
  228.                 break;
  229.             case 'PUT':
  230.                 return self::store($param);
  231.                 break;        
  232.             case 'DELETE':
  233.                 if (!empty($param['id']))
  234.                 {
  235.                     return self::delete($param);
  236.                 }
  237.                 else
  238.                 {
  239.                     return self::deleteAll($param);
  240.                 }
  241.                 break;
  242.         }
  243.     }
  244. }
© Adianti Solutions     Política de privacidade