PHP TRepository::count方法代码示例

 function onReload($param = NULL)
 {
     $offset = $param['offset'];
     //$order   = $param['order'];
     $limit = 10;
     // inicia transação com o banco 'pg_livro'
     TTransaction::open('pg_livro');
     // instancia um repositório para Alunos
     $repository = new TRepository('Pessoa');
     // retorna todos objetos que satisfazem o critério
     $criteria = new TCriteria();
     $count = $repository->count($criteria);
     $criteria->setProperty('limit', $limit);
     $criteria->setProperty('offset', $offset);
     $pessoas = $repository->load($criteria);
     $this->navbar->setPageSize($limit);
     $this->navbar->setCurrentPage($param['page']);
     $this->navbar->setTotalRecords($count);
     $this->datagrid->clear();
     if ($pessoas) {
         foreach ($pessoas as $pessoa) {
             // adiciona o objeto na DataGrid
             $this->datagrid->addItem($pessoa);
         }
     }
     // finaliza a transação
     TTransaction::close();
     $this->loaded = true;
 }

 public function __construct()
 {
     parent::__construct();
     try {
         TTransaction::open('samples');
         $criteria = new TCriteria();
         $criteria->add(new TFilter('name', 'like', 'Rafael%'), TExpression::OR_OPERATOR);
         $criteria->add(new TFilter('name', 'like', 'Ana%'), TExpression::OR_OPERATOR);
         $repository = new TRepository('Customer');
         $count = $repository->count($criteria);
         new TMessage('info', "Total of found customers: {$count} <br>\n");
         TTransaction::close();
     } catch (Exception $e) {
         new TMessage('error', $e->getMessage());
     }
 }

 /**
  * method onGenerate()
  * Executed whenever the user clicks at the generate button
  */
 function onGenerate()
 {
     try {
         // open a transaction with database 'atividade'
         TTransaction::open('atividade');
         // get the form data into an active record
         $formdata = $this->form->getData();
         $validador = new TDuasDatasValidator();
         $validador->validate('Datas', '', array($formdata->ano_atividade_inicial . '-' . str_pad($formdata->mes_atividade_inicial, 2, '0', STR_PAD_LEFT) . '-01', $formdata->ano_atividade_final . '-' . str_pad($formdata->mes_atividade_final, 2, '0', STR_PAD_LEFT) . '-01'));
         $meses = $this->colecaoMeses($formdata);
         $tickets = null;
         $arrayTickets = null;
         if ($formdata->cliente_id > 0) {
             $cliente = Pessoa::getPessoasEntidade($formdata->cliente_id);
             $retorno = Ticket::getTicketsCliente($cliente);
             $arrayTickets = $retorno;
             $tickets = implode(",", $retorno);
         }
         $criteria = new TCriteria();
         $criteria->add(new TFilter("origem", "=", 1));
         $criteria->add(new TFilter("codigo_cadastro_origem", "=", 100));
         $criteria->add(new TFilter("ativo", "=", 1));
         $criteria->add(new TFilter("usuario", "is not "));
         $repo = new TRepository('Pessoa');
         $pessoas = $repo->load($criteria);
         $criteria = new TCriteria();
         $criteria->add(new TFilter('data_atividade', '<', $formdata->ano_atividade_inicial . '-' . str_pad($formdata->mes_atividade_inicial, 2, '0', STR_PAD_LEFT) . '-01'), TExpression::OR_OPERATOR);
         $criteria->add(new TFilter('data_atividade', '>', $formdata->ano_atividade_final . '-' . str_pad($formdata->mes_atividade_final, 2, '0', STR_PAD_LEFT) . '-' . cal_days_in_month(CAL_GREGORIAN, str_pad($formdata->mes_atividade_final, 2, '0', STR_PAD_LEFT), $formdata->ano_atividade_final)), TExpression::OR_OPERATOR);
         $repository = new TRepository('Atividade');
         $count = $repository->count($criteria);
         $format = $formdata->output_type;
         if ($count > 0) {
             $widths = array();
             switch ($format) {
                 case 'html':
                     $tr = new TTableWriterHTML($widths);
                     $break = '<br />';
                     break;
                 case 'pdf':
                     $tr = new TTableWriterPDF($widths);
                     $break = '<br />';
                     break;
                 case 'rtf':
                     if (!class_exists('PHPRtfLite_Autoloader')) {
                         PHPRtfLite::registerAutoloader();
                     }
                     $tr = new TTableWriterRTF($widths);
                     $break = '<br />';
                     break;
             }
             // create the document styles
             $tr->addStyle('title', 'Arial', '10', 'B', '#ffffff', '#6B6B6B');
             $tr->addStyle('datap', 'Arial', '10', '', '#000000', '#E5E5E5');
             $tr->addStyle('datai', 'Arial', '10', '', '#000000', '#ffffff');
             $tr->addStyle('header', 'Times', '16', 'B', '#4A5590', '#C0D3E9');
             $tr->addStyle('footer', 'Times', '12', 'BI', '#4A5590', '#C0D3E9');
             $colunas = count($meses) * 4 + 2;
             $arrayMeses = $this->string->array_meses();
             // add a header row
             $tr->addRow();
             $tr->addCell('RELATORIO XPTO', 'center', 'header', $colunas);
             // add a header row
             $tr->addRow();
             $tr->addCell('Indicadores', 'center', 'header', $colunas);
             // add a header row
             $i = 0;
             $tr->addRow();
             $tr->addCell('', 'center', 'header');
             foreach ($meses as $mes) {
                 $i++;
                 $tr->addCell(substr(strtoupper($arrayMeses[intval(substr($mes, 3, 2))]), 0, 3), 'center', 'header');
                 $tr->addCell('%', 'center', 'header');
                 $tr->addCell('&nbsp;&nbsp;&nbsp;&nbsp;', 'center', 'datai');
             }
             $tr->addCell('TOTAL', 'center', 'header');
             $tr->addCell('%', 'center', 'header');
             // add a carga horaria row
             $i = 0;
             $totalHorario = null;
             $arrayHorario = array();
             $tr->addRow();
             $tr->addCell(utf8_decode('Carga horária mensal:'), 'left', 'datap');
             foreach ($meses as $mes) {
                 $criteria = new TCriteria();
                 $criteria->add(new TFilter("mes", "=", substr($mes, 3, 2)));
                 $criteria->add(new TFilter("ano", "=", substr($mes, 6, 4)));
                 if ($formdata->colaborador_id > 0) {
                     $criteria->add(new TFilter("colaborador_id", "=", $formdata->colaborador_id));
                 }
                 $repo = new TRepository('CargaHoraria');
                 $cargaHoraria = $repo->load($criteria);
                 $horario = null;
                 foreach ($cargaHoraria as $carga) {
                     $horario += $this->string->time_to_sec($carga->horario);
                 }
                 $totalHorario += $horario;
//.........这里部分代码省略.........

 /**
  * method onReload()
  * Load the DETAIL datagrid (backlog)
  */
 function onReload($param = NULL)
 {
     try {
         TTransaction::open('samples');
         // open a transaction
         $repository = new TRepository('Backlog');
         // creates a repository
         $limit = 10;
         // creates a criteria
         $criteria = new TCriteria();
         $criteria->setProperties($param);
         // order, offset
         $criteria->setProperty('limit', $limit);
         // filter the master record
         $criteria->add(new TFilter('project_id', '=', TSession::getValue('project_id')));
         // load the objects according to criteria
         $objects = $repository->load($criteria);
         $this->datagrid->clear();
         if ($objects) {
             foreach ($objects as $object) {
                 $this->datagrid->addItem($object);
                 // add the detail inside the datagrid
             }
         }
         // reset the criteria for record count
         $criteria->resetProperties();
         $count = $repository->count($criteria);
         $this->pageNavigation->setCount($count);
         // count of records
         $this->pageNavigation->setProperties($param);
         // order, page
         $this->pageNavigation->setLimit($limit);
         // limit
         // close the transaction
         TTransaction::close();
         $this->loaded = true;
     } catch (Exception $e) {
         new TMessage('error', '<b>Error</b> ' . $e->getMessage());
         TTransaction::rollback();
     }
 }

 /**
  * method onReload()
  * Load the datagrid with the database objects
  */
 function onReload($param = NULL)
 {
     try {
         // open a transaction with database 'samples'
         TTransaction::open('samples');
         // creates a repository for Customer
         $repository = new TRepository('Customer');
         $limit = 10;
         // creates a criteria
         $criteria = new TCriteria();
         $criteria->setProperties($param);
         // order, offset
         $criteria->setProperty('limit', $limit);
         // load the objects according to criteria
         $objects = $repository->load($criteria);
         $this->datagrid->clear();
         if ($objects) {
             // iterate the collection of active records
             foreach ($objects as $object) {
                 // add the object inside the datagrid
                 $this->datagrid->addItem($object);
             }
         }
         // reset the criteria for record count
         $criteria->resetProperties();
         $count = $repository->count($criteria);
         $this->pageNavigation->setCount($count);
         // count of records
         $this->pageNavigation->setProperties($param);
         // order, page
         $this->pageNavigation->setLimit($limit);
         // limit
         // close the transaction
         TTransaction::close();
         $this->loaded = true;
     } catch (Exception $e) {
         // shows the exception error message
         new TMessage('error', '<b>Error</b> ' . $e->getMessage());
         // undo all pending operations
         TTransaction::rollback();
     }
 }

//.........这里部分代码省略.........
                 $totalPonto = $this->string->sec_to_time($totalPonto);
             }
             // report description
             $tr->addRow();
             $tr->addCell('', 'center', 'title');
             $tr->addCell($titulo, 'center', 'title');
             $tr->addCell("{$this->string->array_meses()[$formdata->mes_atividade]}-{$formdata->ano_atividade}", 'center', 'title', 2);
             // add a header row
             $tr->addRow();
             $tr->addCell('', 'center', 'header');
             $tr->addCell('Indicadores', 'center', 'header');
             $tr->addCell('Horas', 'center', 'header');
             $tr->addCell('%', 'center', 'header');
             // data rows
             $style = 'datai';
             $tr->addRow();
             $tr->addCell('', 'center', $style);
             $tr->addCell(utf8_decode('Carga horária mensal:'), 'left', $style);
             $tr->addCell($this->string->retira_segundos($horario), 'right', $style);
             $tr->addCell('100%', 'right', $style);
             $tr->addRow();
             $tr->addCell('', 'center', $style);
             $tr->addCell(utf8_decode('Horas ponto total:'), 'left', $style);
             $tr->addCell($this->string->retira_segundos($totalPonto), 'right', $style);
             $tr->addCell(round($this->string->time_to_sec($totalPonto) * 100 / $this->string->time_to_sec($horario)) . '%', 'right', $style);
             $cri = new TCriteria();
             if ($formdata->colaborador_id > 0) {
                 $cri->add(new TFilter("colaborador_id", "=", $formdata->colaborador_id));
             }
             $cri->add(new TFilter("ticket_id", "IN", array(328, 514)));
             $cri->add(new TFilter("extract('month' from data_atividade)", "=", $formdata->mes_atividade));
             $cri->add(new TFilter("extract('year' from data_atividade)", "=", $formdata->ano_atividade));
             $repo = new TRepository('Atividade');
             $ausencias = $repo->count($cri);
             if ($ausencias) {
                 $horas = $repo->load($cri);
                 foreach ($horas as $h) {
                     $tempo += $this->string->time_to_sec($h->hora_fim) - $this->string->time_to_sec($h->hora_inicio);
                 }
                 $pontoUtil = $this->string->time_to_sec($totalPonto) - $tempo;
                 $tr->addRow();
                 $tr->addCell('', 'center', $style);
                 $tr->addCell(utf8_decode('Horas ponto útil:'), 'left', $style);
                 $tr->addCell($this->string->retira_segundos($this->string->sec_to_time($pontoUtil)), 'right', $style);
                 $tr->addCell(round($pontoUtil * 100 / $this->string->time_to_sec($horario)) . '%', 'right', $style);
                 $tr->addRow();
                 $tr->addCell('', 'center', 'datap');
                 $tr->addCell(utf8_decode('Horas atividade (indicador total):'), 'left', 'datap');
                 $tr->addCell($this->string->retira_segundos($total), 'right', 'datap');
                 $tr->addCell(round($this->string->time_to_sec($total) * 100 / $this->string->time_to_sec($totalPonto)) . '%', 'right', 'datap');
                 $tr->addRow();
                 $tr->addCell('', 'center', 'datap');
                 $tr->addCell(utf8_decode('Horas atividade (indicador útil):'), 'left', 'datap');
                 $tr->addCell($this->string->retira_segundos($total), 'right', 'datap');
                 $tr->addCell(round($this->string->time_to_sec($total) * 100 / $pontoUtil) . '%', 'right', 'datap');
             } else {
                 $tr->addRow();
                 $tr->addCell('', 'center', $style);
                 $tr->addCell(utf8_decode('Horas atividade:'), 'left', $style);
                 $tr->addCell($this->string->retira_segundos($total), 'right', $style);
                 $tr->addCell(round($this->string->time_to_sec($total) * 100 / $this->string->time_to_sec($totalPonto)) . '%', 'right', $style);
             }
             // division row
             $tr->addRow();
             $tr->addCell($break, 'center', 'datai', 4);
             //ATESTADOS MEDICOS

 /**
  * method onReload()
  * Load the datagrid with the database objects
  */
 function onReload($param = NULL)
 {
     try {
         // open a transaction with database 'atividade'
         TTransaction::open('atividade');
         $logado = Pessoa::retornaUsuario();
         // creates a repository for Ponto
         $repository = new TRepository('Ponto');
         $limit = 10;
         // creates a criteria
         $criteria = new TCriteria();
         $criteria->add(new TFilter('colaborador_id', '=', $logado->pessoa_codigo));
         // default order
         if (empty($param['order'])) {
             $param['order'] = 'data_ponto';
             $param['direction'] = 'desc';
         }
         $criteria->setProperties($param);
         // order, offset
         $criteria->setProperty('limit', $limit);
         if (TSession::getValue('Ponto_filter')) {
             // add the filter stored in the session to the criteria
             $criteria->add(TSession::getValue('Ponto_filter'));
         }
         // load the objects according to criteria
         $objects = $repository->load($criteria, FALSE);
         $this->datagrid->clear();
         if ($objects) {
             // iterate the collection of active records
             foreach ($objects as $object) {
                 // add the object inside the datagrid
                 $object->data_ponto ? $object->data_ponto = $this->string->formatDateBR($object->data_ponto) : null;
                 $this->datagrid->addItem($object);
             }
         }
         // reset the criteria for record count
         $criteria->resetProperties();
         $count = $repository->count($criteria);
         $this->pageNavigation->setCount($count);
         // count of records
         $this->pageNavigation->setProperties($param);
         // order, page
         $this->pageNavigation->setLimit($limit);
         // limit
         // close the transaction
         TTransaction::close();
         $this->loaded = true;
     } catch (Exception $e) {
         new TMessage('error', '<b>Error</b> ' . $e->getMessage());
         // shows the exception error message
         TTransaction::rollback();
         // undo all pending operations
     }
 }

 /**
  * method onReload()
  * Load the datagrid with the database objects
  */
 function onReload($param = NULL)
 {
     try {
         // open a transaction with database 'changeman'
         TTransaction::open('changeman');
         // creates a repository for Issue
         $repository = new TRepository('Issue');
         if (!isset($param['order']) or $param['order'] == 'id') {
             $param['order'] = 'id';
             $param['direction'] = 'desc';
         }
         $limit = 100;
         // creates a criteria
         $criteria = new TCriteria();
         $criteria->setProperties($param);
         // order, offset
         $criteria->setProperty('limit', $limit);
         if (TSession::getValue('Issue_filter')) {
             foreach (TSession::getValue('Issue_filter') as $filter) {
                 // add the filter stored in the session to the criteria
                 $criteria->add($filter);
             }
         }
         $member = Member::newFromLogin(TSession::getValue('login'));
         if ($member->role_mnemonic == 'CUSTOMER') {
             $criteria->add(new TFilter('id_user', '=', $member->id));
         }
         // load the objects according to criteria
         $objects = $repository->load($criteria);
         $this->datagrid->clear();
         if ($objects) {
             // iterate the collection of active records
             foreach ($objects as $object) {
                 // add the object inside the datagrid
                 $this->datagrid->addItem($object);
             }
         }
         // reset the criteria for record count
         $criteria->resetProperties();
         $count = $repository->count($criteria);
         $this->pageNavigation->setCount($count);
         // count of records
         $this->pageNavigation->setProperties($param);
         // order, page
         $this->pageNavigation->setLimit($limit);
         // limit
         // close the transaction
         TTransaction::close();
         $this->loaded = true;
     } catch (Exception $e) {
         // shows the exception error message
         new TMessage('error', '<b>Error</b> ' . $e->getMessage());
         // undo all pending operations
         TTransaction::rollback();
     }
 }

 /**
  * method onReload()
  * Load the datagrid with the database objects
  */
 function onReload($param = NULL)
 {
     try {
         // open a transaction with database 'samples'
         TTransaction::open('db_crmbf');
         // creates a repository for Customer
         $repository = new TRepository('CRM');
         $limit = 10;
         // creates a criteria
         $criteria = new TCriteria();
         //            if (isset($param['order']) AND $param['order'] == 'city_name')
         //            {
         //                $param['order'] = '(select name from city where city_id = id)';
         //            }
         //$criteria->setProperties($param); // order, offset
         // add the filter stored in the session to the criteria
         $criteria->add(new TFilter('cliente_id', '=', $_GET['key']));
         $criteria->setProperty('order', 'id desc');
         // order, offset
         //   $criteria->setProperty('limit', $limit);
         /*
          if (TSession::getValue('customer_filter1'))
          {
          // add the filter stored in the session to the criteria
          $criteria->add(TSession::getValue('customer_filter1'));
          }
         
          if (TSession::getValue('customer_filter2'))
          {
          // add the filter stored in the session to the criteria
          $criteria->add(TSession::getValue('customer_filter2'));
          }
         
         * 
         */
         // load the objects according to criteria
         $customers = $repository->load($criteria);
         $this->datagrid->clear();
         if ($customers) {
             foreach ($customers as $customer) {
                 // add the object inside the datagrid
                 $this->datagrid->addItem($customer);
             }
         }
         // reset the criteria for record count
         $criteria->resetProperties();
         $count = $repository->count($criteria);
         $this->pageNavigation->setCount($count);
         // count of records
         $this->pageNavigation->setProperties($param);
         // order, page
         $this->pageNavigation->setLimit($limit);
         // limit
         // close the transaction
         TTransaction::close();
         $this->loaded = true;
     } catch (Exception $e) {
         // in case of exception
         // shows the exception error message
         new TMessage('error', '<b>Error</b> ' . $e->getMessage());
         // undo all pending operations
         TTransaction::rollback();
     }
 }

 /**
  * method onReload()
  * Load the datagrid with the database objects
  */
 function onReload($param = NULL)
 {
     try {
         // open a transaction with database 'sample'
         TTransaction::open('sample');
         // creates a repository for Produtos
         $repository = new TRepository('Produtos');
         $limit = 10;
         // creates a criteria
         $criteria = new TCriteria();
         // default order
         if (empty($param['order'])) {
             $param['order'] = 'id';
             $param['direction'] = 'asc';
         }
         $criteria->setProperties($param);
         // order, offset
         $criteria->setProperty('limit', $limit);
         if (TSession::getValue('Produtos_filter')) {
             // add the filter stored in the session to the criteria
             $criteria->add(TSession::getValue('Produtos_filter'));
         }
         // load the objects according to criteria
         $objects = $repository->load($criteria, FALSE);
         $this->datagrid->clear();
         if ($objects) {
             // iterate the collection of active records
             foreach ($objects as $object) {
                 $img = new TImage('uploads/' . $object->imagem);
                 $img->width = '100px';
                 $img->heigth = '120px';
                 $object->imagem = $img;
                 // add the object inside the datagrid
                 $this->datagrid->addItem($object);
             }
         }
         // reset the criteria for record count
         $criteria->resetProperties();
         $count = $repository->count($criteria);
         $this->pageNavigation->setCount($count);
         // count of records
         $this->pageNavigation->setProperties($param);
         // order, page
         $this->pageNavigation->setLimit($limit);
         // limit
         // close the transaction
         TTransaction::close();
         $this->loaded = true;
     } catch (Exception $e) {
         // shows the exception error message
         new TMessage('error', '<b>Error</b> ' . $e->getMessage());
         // undo all pending operations
         TTransaction::rollback();
     }
 }

 /**
  * Load the datagrid with data
  */
 public function onReload($param = NULL)
 {
     try {
         // open a transaction with database 'sample'
         TTransaction::open('sample');
         // creates a repository for telefone
         $repository = new TRepository('telefone');
         $limit = 10;
         // creates a criteria
         $criteria = new TCriteria();
         $filter = new TFilter('clientes_id', '=', $param['key']);
         $criteria->add($filter);
         // default order
         if (empty($param['order'])) {
             $param['order'] = 'id';
             $param['direction'] = 'asc';
         }
         $criteria->setProperties($param);
         // order, offset
         $criteria->setProperty('limit', $limit);
         // load the objects according to criteria
         $objects = $repository->load($criteria, FALSE);
         if (is_callable($this->transformCallback)) {
             call_user_func($this->transformCallback, $objects, $param);
         }
         $this->datagrid->clear();
         if ($objects) {
             // iterate the collection of active records
             foreach ($objects as $object) {
                 // add the object inside the datagrid
                 $this->datagrid->addItem($object);
             }
         }
         // reset the criteria for record count
         $criteria->resetProperties();
         $count = $repository->count($criteria);
         $this->pageNavigation->setCount($count);
         // count of records
         $this->pageNavigation->setProperties($param);
         // order, page
         $this->pageNavigation->setLimit($limit);
         // limit
         // close the transaction
         TTransaction::close();
         $this->loaded = true;
     } catch (Exception $e) {
         // shows the exception error message
         new TMessage('error', $e->getMessage());
         // undo all pending operations
         TTransaction::rollback();
     }
 }

 /**
  * method onReload()
  * Load the datagrid with the database objects
  */
 function onReload($param = NULL)
 {
     try {
         // open a transaction with database 'samples'
         TTransaction::open('samples');
         // creates a repository for Product
         $repository = new TRepository('Product');
         $limit = 10;
         // creates a criteria
         $criteria = new TCriteria();
         $criteria->setProperties($param);
         // order, offset
         $criteria->setProperty('limit', $limit);
         // update the save action parameters to pass
         // offset, limit, page and other info to the save action
         $this->saveAction->setParameters($param);
         // important!
         // load the objects according to criteria
         $objects = $repository->load($criteria);
         $this->datagrid->clear();
         if ($objects) {
             // iterate the collection of active records
             foreach ($objects as $object) {
                 $object->sale_price_edit = new TEntry('sale_price_' . $object->id);
                 $object->sale_price_edit->setNumericMask(1, '.', ',');
                 $object->sale_price_edit->setSize(120);
                 $object->sale_price_edit->setValue($object->sale_price);
                 $this->form->addField($object->sale_price_edit);
                 // important!
                 // add the object inside the datagrid
                 $this->datagrid->addItem($object);
             }
         }
         // reset the criteria for record count
         $criteria->resetProperties();
         $count = $repository->count($criteria);
         $this->pageNavigation->setCount($count);
         // count of records
         $this->pageNavigation->setProperties($param);
         // order, page
         $this->pageNavigation->setLimit($limit);
         // limit
         // close the transaction
         TTransaction::close();
         $this->loaded = true;
     } catch (Exception $e) {
         // shows the exception error message
         new TMessage('error', '<b>Error</b> ' . $e->getMessage());
         // undo all pending operations
         TTransaction::rollback();
     }
 }

 /**
  * method onReload()
  * Load the datagrid with the database objects
  */
 function onReload($param = NULL)
 {
     try {
         // open a transaction with database 'samples'
         TTransaction::open('samples');
         // creates a repository for Product
         $repository = new TRepository('Product');
         $limit = 10;
         // creates a criteria
         $criteria = new TCriteria();
         $criteria->setProperties($param);
         // order, offset
         $criteria->setProperty('limit', $limit);
         $criteria->setProperty('order', 'description');
         if (TSession::getValue('product_filter1')) {
             // add the filter stored in the session to the criteria
             $criteria->add(TSession::getValue('product_filter1'));
         }
         // load the objects according to criteria
         $products = $repository->load($criteria);
         $this->datagrid->clear();
         if ($products) {
             foreach ($products as $product) {
                 // add the object inside the datagrid
                 $this->datagrid->addItem($product);
             }
         }
         $this->cartgrid->clear();
         $cart_objects = TSession::getValue('cart_objects');
         $total = 0;
         if ($cart_objects) {
             foreach ($cart_objects as $object) {
                 $this->cartgrid->addItem($object);
                 $total += $object->sale_price;
             }
         }
         $this->total->setValue(number_format($total));
         // reset the criteria for record count
         $criteria->resetProperties();
         $count = $repository->count($criteria);
         $this->pageNavigation->setCount($count);
         // count of records
         $this->pageNavigation->setProperties($param);
         // order, page
         $this->pageNavigation->setLimit($limit);
         // limit
         // close the transaction
         TTransaction::close();
         $this->loaded = true;
     } catch (Exception $e) {
         // shows the exception error message
         new TMessage('error', '<b>Error</b> ' . $e->getMessage());
         // undo all pending operations
         TTransaction::rollback();
     }
 }

    // segundo exemplo, Contar todas as turmas com aula na sala
    // "100" no turno da Tarde OU na "200" pelo turno da manha.
    TTransaction::log("** Conta Turmas");
    // instancia um critério de seleção
    // sala "100" e turno "T" (tarde)
    $criteria1 = new TCriteria();
    $criteria1->add(new TFilter('sala', '=', '100'));
    $criteria1->add(new TFilter('turno', '=', 'T'));
    // instancia um critério de seleção
    // sala "200" e turno "M" (manha)
    $criteria2 = new TCriteria();
    $criteria2->add(new TFilter('sala', '=', '200'));
    $criteria2->add(new TFilter('turno', '=', 'M'));
    // instancia um critério de seleção
    // com OU para juntar os critérios anteriores
    $criteria = new TCriteria();
    $criteria->add($criteria1, TExpression::OR_OPERATOR);
    $criteria->add($criteria2, TExpression::OR_OPERATOR);
    // instancia um repositório de Turmas
    $repository = new TRepository('Turma');
    // retorna quantos objetos satisfazem o critério
    $count = $repository->count($criteria);
    echo "Total de turmas: {$count} <br>\n";
    // finaliza a transação
    TTransaction::close();
} catch (Exception $e) {
    // exibe a mensagem gerada pela exceção
    echo '<b>Erro</b>' . $e->getMessage();
    // desfaz todas alterações no banco de dados
    TTransaction::rollback();
}

//.........这里部分代码省略.........
             $calculaHoras = true;
             $pesquisaNormal = true;
         }
         if (TSession::getValue('AtividadeList_filter_ticket_id')) {
             $criteria->add(TSession::getValue('AtividadeList_filter_ticket_id'));
             // add the session filter
             $criHoras->add(TSession::getValue('AtividadeList_filter_ticket_id'));
             // add the session filter
             $calculaHoras = true;
             $pesquisaNormal = true;
         }
         if (TSession::getValue('AtividadeList_filter_pesquisa_master')) {
             try {
                 TTransaction::open('atividade');
                 $pesquisa_master = TSession::getValue('AtividadeList_filter_pesquisa_master');
                 $repo = new TRepository('Ticket');
                 $tickets = $repo->where('titulo', 'ilike', "%{$pesquisa_master}%")->load();
                 $clausula[] = '0';
                 foreach ($tickets as $ticket) {
                     $clausula[] = $ticket->id;
                 }
                 TTransaction::close();
             } catch (Exception $e) {
                 new TMessage('error', $e->getMessage());
             }
             $criteria2->add(new TFilter('ticket_id', 'IN', $clausula), TExpression::OR_OPERATOR);
             $criteria2->add(new TFilter('descricao', 'ilike', "%{$pesquisa_master}%"), TExpression::OR_OPERATOR);
             $criHoras2->add(new TFilter('ticket_id', 'IN', $clausula), TExpression::OR_OPERATOR);
             $criHoras2->add(new TFilter('descricao', 'ilike', "%{$pesquisa_master}%"), TExpression::OR_OPERATOR);
             $calculaHoras = true;
         }
         if (TSession::getValue('AtividadeList_filter_pesquisa_master')) {
             if (!$pesquisaNormal) {
                 $criteriaFinal = $criteria2;
                 $criteriaHorasFinal = $criHoras2;
                 $criteriaFinal->setProperties($newparam);
                 // order, offset
                 $criteriaFinal->setProperty('limit', $limit);
             } else {
                 $criteriaFinal = new TCriteria();
                 $criteriaFinal->add($criteria);
                 $criteriaFinal->add($criteria2);
                 $criteriaFinal->setProperties($newparam);
                 // order, offset
                 $criteriaFinal->setProperty('limit', $limit);
                 $criteriaHorasFinal = new TCriteria();
                 $criteriaHorasFinal->add($criHoras);
                 $criteriaHorasFinal->add($criHoras2);
             }
         } else {
             $criteriaFinal = $criteria;
             $criteriaHorasFinal = $criHoras;
         }
         if ($calculaHoras) {
             $repo = new TRepository('Atividade');
             $horas = $repo->load($criteriaHorasFinal, FALSE);
             $totalHoras = null;
             if ($horas) {
                 foreach ($horas as $hora) {
                     $HoraEntrada = new DateTime($hora->hora_inicio);
                     $HoraSaida = new DateTime($hora->hora_fim);
                     $diferenca = $HoraSaida->diff($HoraEntrada)->format('%H:%I:%S');
                     $totalHoras += $this->string->time_to_sec($diferenca);
                 }
             }
             $this->onTotalAtividades(substr($this->string->sec_to_time($totalHoras), 0, -3));
         }
         // load the objects according to criteria
         $objects = $repository->load($criteriaFinal, FALSE);
         $this->datagrid->clear();
         try {
             if ($objects) {
                 // iterate the collection of active records
                 foreach ($objects as $object) {
                     // add the object inside the datagrid
                     $this->datagrid->addItem($object);
                 }
             }
         } catch (Exception $e) {
             new TMessage('error', '<b>Error</b> ' . $e->getMessage());
         }
         // reset the criteria for record count
         $criteriaFinal->resetProperties();
         $count = $repository->count($criteriaFinal);
         $this->pageNavigation->setCount($count);
         // count of records
         $this->pageNavigation->setProperties($param);
         // order, page
         $this->pageNavigation->setLimit($limit);
         // limit
         // close the transaction
         TTransaction::close();
         $this->loaded = true;
     } catch (Exception $e) {
         // shows the exception error message
         new TMessage('error', '<b>Error</b> ' . $e->getMessage());
         // undo all pending operations
         TTransaction::rollback();
     }
 }