Lançado Adianti Framework 7.6!
Clique aqui para saber mais
Conheça Características Quem usa Galeria Cursos Docs Fórum
Downloads
Posts Fique por dentro Sobre o Fórum Minha conta
Carregar dados de Composição na Datagrid Possuo uma classe Prova e uma outra chamada Alternativa. Elas estão relacionadas por Composição. Gostaria que uma célula da datagrid que mostra as provas cadastradas trouxesse TODAS as alternativas cadastradas para a respectiva prova. Não entendi como fazer a array de dados aparecer numa única célula da datagrid. O que estou fazendo errado? ...
CS
Carregar dados de Composição na Datagrid  
cleber silva 06/04/2019 (há 5 anos)
Possuo uma classe Prova e uma outra chamada Alternativa. Elas estão relacionadas por Composição. Gostaria que uma célula da datagrid que mostra as provas cadastradas trouxesse TODAS as alternativas cadastradas para a respectiva prova. Não entendi como fazer a array de dados aparecer numa única célula da datagrid. O que estou fazendo errado?

  1. <?php
  1. <?php
  3. class Prova extends TRecord
  4. {
  5.     const TABLENAME = 'prova';
  6.     const PRIMARYKEY= 'id';
  7.     const IDPOLICY =  'serial'; // {max, serial}
  8.     
  9.     
  10.     private $alternativas;
  11.     private $curso;
  13.     /**
  14.      * Constructor method
  15.      */
  16.     public function __construct($id = NULL, $callObjectLoad = TRUE)
  17.     {
  18.         parent::__construct($id, $callObjectLoad);
  19.         parent::addAttribute('texto_questao');
  20.         parent::addAttribute('caminho_imagem');
  21.         parent::addAttribute('curso_id');
  22.     }
  24.     
  25.     /**
  26.      * Method addAlternativa
  27.      * Add a Alternativa to the Prova
  28.      * @param $object Instance of Alternativa
  29.      */
  30.     public function addAlternativa(Alternativa $object)
  31.     {
  32.         $this->alternativas[] = $object;
  33.     }
  34.     
  35.     /**
  36.      * Method getAlternativas
  37.      * Return the Prova' Alternativa's
  38.      * @return Collection of Alternativa
  39.      */
  40.     public function getAlternativas()
  41.     {
  42.     // loads the associated object
  43.     if (empty($this->alternativa))
  44.    //     $this->alternativa = Alternativa::where('prova_id', '=', $id)->load();
  45.         
  46.   //          foreach ($this->alternativa as $alt)
  47.    //         {
  48.    //             $return $alt;
  49.    //         }
  50.     
  51.     // returns the associated object
  52.    return $this->alternativa;
  53.     }
  54.      
  55.     
  56.     /**
  57.      * Method getCurso
  58.      * Return the Prova' Curso's
  59.      * @return Collection of Curso
  60.      */
  61.     
  62.     public function get_curso()
  63.     {
  64.     // loads the associated object
  65.     if (empty($this->curso))
  66.         $this->curso = new Curso($this->curso_id);
  67.     
  68.     // returns the associated object
  69.     return $this->curso;
  70.     }
  72.     /**
  73.      * Reset aggregates
  74.      */
  75.     public function clearParts()
  76.     {
  77.         $this->alternativas = array();
  78.     }
  80.     /**
  81.      * Load the object and its aggregates
  82.      * @param $id object ID
  83.      */
  84.     public function load($id)
  85.     {
  86.     
  87.         // load the related Alternativa objects
  88.         $repository = new TRepository('Alternativa');
  89.         $criteria = new TCriteria;
  90.         $criteria->add(new TFilter('prova_id', '=', $id));
  91.         $this->alternativas = $repository->load($criteria);
  92.     
  93.         // load the object itself
  94.         return parent::load($id);
  95.     }
  97.     /**
  98.      * Store the object and its aggregates
  99.      */
  100.     public function store()
  101.     {
  102.         // store the object itself
  103.         parent::store();
  104.     
  105.         // delete the related Alternativa objects
  106.         $criteria = new TCriteria;
  107.         $criteria->add(new TFilter('prova_id', '=', $this->id));
  108.         $repository = new TRepository('Alternativa');
  109.         $repository->delete($criteria);
  110.         // store the related Alternativa objects
  111.         if ($this->alternativas)
  112.         {
  113.             foreach ($this->alternativas as $alternativa)
  114.             {
  115.                 unset($alternativa->id);
  116.                 $alternativa->prova_id = $this->id;
  117.                 $alternativa->store();
  118.             }
  119.         }
  120.     }
  122.     /**
  123.      * Delete the object and its aggregates
  124.      * @param $id object ID
  125.      */
  126.     public function delete($id = NULL)
  127.     {
  128.         $id = isset($id) ? $id : $this->id;
  129.         // delete the related Alternativa objects
  130.         $repository = new TRepository('Alternativa');
  131.         $criteria = new TCriteria;
  132.         $criteria->add(new TFilter('prova_id', '=', $id));
  133.         $repository->delete($criteria);
  134.         
  135.     
  136.         // delete the object itself
  137.         parent::delete($id);
  138.     }
  141. }
  144. ?>
Pacotão Dominando o Adianti Framework 7
O material mais completo de treinamento do Framework.
Curso em vídeo aulas + Livro completo + Códigos fontes do projeto ERPHouse.
Conteúdo Atualizado! Versão 7.4


Dominando o Adianti 7 Quero me inscrever agora!

Comentários (3)

CS
cleber silva - AUTOR DO POST       06/04/2019 (há 5 anos)

  1. <?php
  3. class ProvaList extends TPage
  4. {
  5.     private $form; // form
  6.     private $datagrid; // listing
  7.     private $pageNavigation;
  8.     private $formgrid;
  9.     private $loaded;
  10.     private $deleteButton;
  11.     
  12.     /**
  13.      * Class constructor
  14.      * Creates the page, the form and the listing
  15.      */
  16.     public function __construct()
  17.     {
  18.         parent::__construct();
  19.         
  20.         // creates the form
  21.         $this->form = new BootstrapFormBuilder('form_Prova');
  22.         $this->form->setFormTitle('Prova');
  23.         
  25.         // create the form fields
  26.         $id = new TEntry('id');
  27.         $texto_questao = new TEntry('texto_questao');
  28.         $caminho_imagem = new TEntry('caminho_imagem');
  29.         $curso_id = new TDBUniqueSearch('curso_id', 'permission', 'Curso', 'id', 'nome');
  32.         // add the fields
  33.         $this->form->addFields( [ new TLabel('Id') ], [ $id ] );
  34.         $this->form->addFields( [ new TLabel('Texto Questao') ], [ $texto_questao ] );
  35.         $this->form->addFields( [ new TLabel('Caminho Imagem') ], [ $caminho_imagem ] );
  36.         $this->form->addFields( [ new TLabel('Curso Id') ], [ $curso_id ] );
  39.         // set sizes
  40.         $id->setSize('100%');
  41.         $texto_questao->setSize('100%');
  42.         $caminho_imagem->setSize('100%');
  43.         $curso_id->setSize('100%');
  45.         
  46.         // keep the form filled during navigation with session data
  47.         $this->form->setData( TSession::getValue('Prova_filter_data') );
  48.         
  49.         // add the search form actions
  50.         $btn = $this->form->addAction(_t('Find'), new TAction([$this, 'onSearch']), 'fa:search');
  51.         $btn->class = 'btn btn-sm btn-primary';
  52.         $this->form->addActionLink(_t('New'), new TAction(['ProvaForm', 'onEdit']), 'fa:plus green');
  53.         
  54.         // creates a Datagrid
  55.         $this->datagrid = new BootstrapDatagridWrapper(new TDataGrid);
  56.         $this->datagrid->style = 'width: 100%';
  57.         $this->datagrid->datatable = 'true';
  58.     //    $this->datagrid->enablePopover('Popover', 'Hi <b> {Prova::getAlternativas(id)} </b>');
  59.         
  61.         // creates the datagrid columns
  62.         $column_id = new TDataGridColumn('id', 'Id', 'right');
  63.         $column_texto_questao = new TDataGridColumn('texto_questao', 'Texto Questao', 'left');
  64.         $column_caminho_imagem = new TDataGridColumn('caminho_imagem', 'Caminho Imagem', 'left');
  65.         $column_curso_id = new TDataGridColumn('curso->nome', 'Curso', 'right');
  66.  //       $column_id1 = new TDataGridColumn('alternativa', 'Alternativas', 'right');
  69.         // add the columns to the DataGrid
  70.         $this->datagrid->addColumn($column_id);
  71.         $this->datagrid->addColumn($column_texto_questao);
  72.         $this->datagrid->addColumn($column_caminho_imagem);
  73.         $this->datagrid->addColumn($column_curso_id);
  74.   //      $this->datagrid->addColumn($column_id1);
  76.         
  77.         // create EDIT action
  78.         $action_edit = new TDataGridAction(['ProvaForm', 'onEdit']);
  79.         //$action_edit->setUseButton(TRUE);
  80.         //$action_edit->setButtonClass('btn btn-default');
  81.         $action_edit->setLabel(_t('Edit'));
  82.         $action_edit->setImage('fa:pencil-square-o blue fa-lg');
  83.         $action_edit->setField('id');
  84.         $this->datagrid->addAction($action_edit);
  85.         
  86.         // create DELETE action
  87.         $action_del = new TDataGridAction(array($this, 'onDelete'));
  88.         //$action_del->setUseButton(TRUE);
  89.         //$action_del->setButtonClass('btn btn-default');
  90.         $action_del->setLabel(_t('Delete'));
  91.         $action_del->setImage('fa:trash-o red fa-lg');
  92.         $action_del->setField('id');
  93.         $this->datagrid->addAction($action_del);
  94.         
  95.         // create DELETE action
  96.         $action_view= new TDataGridAction(array($this, 'onView'));
  97.         //$action_del->setUseButton(TRUE);
  98.         //$action_del->setButtonClass('btn btn-default');
  99.         $action_view->setLabel('Visualizar Alternativas');
  100.         $action_view->setImage('fa:search-plus green fa-lg');
  101.         $action_view->setField('id');
  102.         $this->datagrid->addAction($action_view);
  103.         
  104.         // create the datagrid model
  105.         $this->datagrid->createModel();
  106.         
  107.         // creates the page navigation
  108.         $this->pageNavigation = new TPageNavigation;
  109.         $this->pageNavigation->setAction(new TAction([$this, 'onReload']));
  110.         $this->pageNavigation->setWidth($this->datagrid->getWidth());
  111.         
  114.         // vertical box container
  115.         $container = new TVBox;
  116.         $container->style = 'width: 90%';
  117.         // $container->add(new TXMLBreadCrumb('menu.xml', __CLASS__));
  118.         $container->add($this->form);
  119.         $container->add(TPanelGroup::pack('', $this->datagrid, $this->pageNavigation));
  120.         
  121.         parent::add($container);
  122.     }
  123.     
  124.     /**
  125.      * Inline record editing
  126.      * @param $param Array containing:
  127.      *              key: object ID value
  128.      *              field name: object attribute to be updated
  129.      *              value: new attribute content 
  130.      */
  131.     public function onInlineEdit($param)
  132.     {
  133.         try
  134.         {
  135.             // get the parameter $key
  136.             $field = $param['field'];
  137.             $key   = $param['key'];
  138.             $value = $param['value'];
  139.             
  140.             TTransaction::open('permission'); // open a transaction with database
  141.             $object = new Prova($key); // instantiates the Active Record
  142.             $object->{$field} = $value;
  143.             $object->store(); // update the object in the database
  144.             TTransaction::close(); // close the transaction
  145.             
  146.             $this->onReload($param); // reload the listing
  147.             new TMessage('info', "Record Updated");
  148.         }
  149.         catch (Exception $e) // in case of exception
  150.         {
  151.             new TMessage('error', $e->getMessage()); // shows the exception error message
  152.             TTransaction::rollback(); // undo all pending operations
  153.         }
  154.     }
  155.     
  156.     /**
  157.      * Register the filter in the session
  158.      */
  159.     public function onSearch()
  160.     {
  161.         // get the search form data
  162.         $data = $this->form->getData();
  163.         
  164.         // clear session filters
  165.         TSession::setValue('ProvaList_filter_id',   NULL);
  166.         TSession::setValue('ProvaList_filter_texto_questao',   NULL);
  167.         TSession::setValue('ProvaList_filter_caminho_imagem',   NULL);
  168.         TSession::setValue('ProvaList_filter_curso_id',   NULL);
  170.         if (isset($data->id) AND ($data->id)) {
  171.             $filter = new TFilter('id', '=', "$data->id"); // create the filter
  172.             TSession::setValue('ProvaList_filter_id',   $filter); // stores the filter in the session
  173.         }
  176.         if (isset($data->texto_questao) AND ($data->texto_questao)) {
  177.             $filter = new TFilter('texto_questao', 'like', "%{$data->texto_questao}%"); // create the filter
  178.             TSession::setValue('ProvaList_filter_texto_questao',   $filter); // stores the filter in the session
  179.         }
  182.         if (isset($data->caminho_imagem) AND ($data->caminho_imagem)) {
  183.             $filter = new TFilter('caminho_imagem', 'like', "%{$data->caminho_imagem}%"); // create the filter
  184.             TSession::setValue('ProvaList_filter_caminho_imagem',   $filter); // stores the filter in the session
  185.         }
  188.         if (isset($data->curso_id) AND ($data->curso_id)) {
  189.             $filter = new TFilter('curso_id', '=', "$data->curso_id"); // create the filter
  190.             TSession::setValue('ProvaList_filter_curso_id',   $filter); // stores the filter in the session
  191.         }
  193.         
  194.         // fill the form with data again
  195.         $this->form->setData($data);
  196.         
  197.         // keep the search data in the session
  198.         TSession::setValue('Prova_filter_data', $data);
  199.         
  200.         $param = array();
  201.         $param['offset']    =0;
  202.         $param['first_page']=1;
  203.         $this->onReload($param);
  204.     }
  205.     
  206.     /**
  207.      * Load the datagrid with data
  208.      */
  209.     public function onReload($param = NULL)
  210.     {
  211.         try
  212.         {
  213.             // open a transaction with database 'permission'
  214.             TTransaction::open('permission');
  215.             
  216.             
  217.             // creates a repository for Prova
  218.             $repository = new TRepository('Prova');
  219.             $limit = 10;
  220.             // creates a criteria
  221.             $criteria = new TCriteria;
  222.             
  223.             // default order
  224.             if (empty($param['order']))
  225.             {
  226.                 $param['order'] = 'id';
  227.                 $param['direction'] = 'asc';
  228.             }
  229.             $criteria->setProperties($param); // order, offset
  230.             $criteria->setProperty('limit', $limit);
  231.             
  233.             if (TSession::getValue('ProvaList_filter_id')) {
  234.                 $criteria->add(TSession::getValue('ProvaList_filter_id')); // add the session filter
  235.             }
  238.             if (TSession::getValue('ProvaList_filter_texto_questao')) {
  239.                 $criteria->add(TSession::getValue('ProvaList_filter_texto_questao')); // add the session filter
  240.             }
  243.             if (TSession::getValue('ProvaList_filter_caminho_imagem')) {
  244.                 $criteria->add(TSession::getValue('ProvaList_filter_caminho_imagem')); // add the session filter
  245.             }
  248.             if (TSession::getValue('ProvaList_filter_curso_id')) {
  249.                 $criteria->add(TSession::getValue('ProvaList_filter_curso_id')); // add the session filter
  250.             }
  252.       //  $alternativa = Alternativa::where('prova_id', '=', '1')->load();
  253.       //  $this->datagrid->addItems($alternativa);
  254.             
  255.             // load the objects according to criteria
  256.             $objects = $repository->load($criteria, FALSE);
  257.             
  258.             if (is_callable($this->transformCallback))
  259.             {
  260.                 call_user_func($this->transformCallback, $objects, $param);
  261.             }
  262.             
  263.             $this->datagrid->clear();
  264.             if ($objects)
  265.             {
  266.                 // iterate the collection of active records
  267.                 foreach ($objects as $object)
  268.                 {
  269.                     // add the object inside the datagrid
  270.                     $this->datagrid->addItem($object);
  271.                 }
  273.             }
  275.             
  276.             // reset the criteria for record count
  277.             $criteria->resetProperties();
  278.             $count= $repository->count($criteria);
  279.             
  280.             $this->pageNavigation->setCount($count); // count of records
  281.             $this->pageNavigation->setProperties($param); // order, page
  282.             $this->pageNavigation->setLimit($limit); // limit
  283.             
  284.             // close the transaction
  285.             TTransaction::close();
  286.             $this->loaded = true;
  287.         }
  288.         catch (Exception $e) // in case of exception
  289.         {
  290.             // shows the exception error message
  291.             new TMessage('error', $e->getMessage());
  292.             // undo all pending operations
  293.             TTransaction::rollback();
  294.         }
  295.     }
  296.     
  297.     /**
  298.      * Ask before deletion
  299.      */
  300.     public static function onDelete($param)
  301.     {
  302.         // define the delete action
  303.         $action = new TAction([__CLASS__, 'Delete']);
  304.         $action->setParameters($param); // pass the key parameter ahead
  305.         
  306.         // shows a dialog to the user
  307.         new TQuestion(TAdiantiCoreTranslator::translate('Do you really want to delete ?'), $action);
  308.     }
  309.     
  310.     /**
  311.      * Delete a record
  312.      */
  313.     public static function Delete($param)
  314.     {
  315.         try
  316.         {
  317.             $key=$param['key']; // get the parameter $key
  318.             TTransaction::open('permission'); // open a transaction with database
  319.             $object = new Prova($key, FALSE); // instantiates the Active Record
  320.             $object->delete(); // deletes the object from the database
  321.             TTransaction::close(); // close the transaction
  322.             
  323.             $pos_action = new TAction([__CLASS__, 'onReload']);
  324.             new TMessage('info', TAdiantiCoreTranslator::translate('Record deleted'), $pos_action); // success message
  325.         }
  326.         catch (Exception $e) // in case of exception
  327.         {
  328.             new TMessage('error', $e->getMessage()); // shows the exception error message
  329.             TTransaction::rollback(); // undo all pending operations
  330.         }
  331.     }
  332.     
  334.     /**
  335.      * Delete a record
  336.      */
  337.     public static function onView($param)
  338.     {
  339.         try
  340.         {
  341.             $key = $param['key'];
  342.             $win = TWindow::create('Alternativas', 0.6, 0.4);
  343.             TTransaction::open('permission');
  344.             
  345.             $pergunta = new Prova($key);
  346.             
  347.             $alternativas = Alternativa::where('prova_id', '=', $key)->load();
  348.             $win->add("$pergunta->texto_questao<br><br>");
  349.             if ($alternativas)
  350.             {
  351.                 $win->add("<ol type='A'>");
  352.                 foreach ($alternativas as $alt)
  353.                 {
  354.                     $win->add("<li>$alt->texto_alternativa</li>");
  355.                 }
  356.                 $win->add("</ol>");
  357.             }
  358.             
  360.         
  361.             $win->show();
  362.           TTransaction::close();
  363.         }
  364.         catch (Exception $e) // in case of exception
  365.         {
  366.             new TMessage('error', $e->getMessage()); // shows the exception error message
  367.             TTransaction::rollback(); // undo all pending operations
  368.         }
  369.     }
  371.     
  372.     /**
  373.      * method show()
  374.      * Shows the page
  375.      */
  376.     public function show()
  377.     {
  378.         // check if the datagrid is already loaded
  379.         if (!$this->loaded AND (!isset($_GET['method']) OR !(in_array($_GET['method'],  array('onReload', 'onSearch')))) )
  380.         {
  381.             if (func_num_args() > 0)
  382.             {
  383.                 $this->onReload( func_get_arg(0) );
  384.             }
  385.             else
  386.             {
  387.                 $this->onReload();
  388.             }
  389.         }
  390.         parent::show();
  391.     }
  392. }
  393. ?>
FC
Felipe Cortez       08/04/2019 (há 5 anos)

Cleber

Se entendi, vc precisa de uma datagrid onde mostre "grupos" de "alternativas" por "prova" imagino que seja isso.

Tenta usar o setGroup
$this->datagrid->setGroupColumn(....

Exemplo
adianti.com.br/framework_files/tutor/index.php?class=DatagridColumnG
CS
cleber silva - AUTOR DO POST       09/04/2019 (há 5 anos)

Felipe,

muito obrigado. A sua dica resolveu o meu problema!