Conheça Características Quem usa Galeria Cursos Docs Fórum
Downloads
Posts Fique por dentro Sobre o Fórum Minha conta
CADASTRO DE PESSOAS x ORDEM DE SERVIÇOS - TDBRadioGroup e TDBUni Olá pessoal. Estou aproveitando o código fonte do cadastro de PESSOAS da aplicação MICROERP lançado agora na versão 5.0. Neste cadastro existe um TDBRadioGroup, que possibilita ao usuário fazer uma marcação de um GRUPO para a pessoa que está sendo cadastrada. Como vocês podem ver na imagem do anexo, vou classificar como CLIENTE; FORNECEDOR e FUNCIONÁRIO. Também tenho na ...
HB
CADASTRO DE PESSOAS x ORDEM DE SERVIÇOS - TDBRadioGroup e TDBUni  
Humberto Vilas Boas 27/11/2017 (há 7 anos)
Olá pessoal.
Estou aproveitando o código fonte do cadastro de PESSOAS da aplicação MICROERP lançado agora na versão 5.0.

Neste cadastro existe um TDBRadioGroup, que possibilita ao usuário fazer uma marcação de um GRUPO para a pessoa que está sendo cadastrada. Como vocês podem ver na imagem do anexo, vou classificar como CLIENTE; FORNECEDOR e FUNCIONÁRIO.

Também tenho na minha aplicação de controle de oficina mecânica um cadastro de ordem de serviço, que estou re-aproveitamento o código fonte do cadastro de PEDIDO.
Como o cadastro de pessoas tem essa separação do grupo de pessoas, eu gostaria de fazer um tratamento no momento de cadastrar a minha ordem de serviço, que é exibir no campo CLIENTE (vejam na imagem) somente a pessoa classificada no grupo CLIENTE, e no campo MECÂNICO, exibir somente a pessoa classifica no grupo FUNCIONÁRIO.

Como sou ainda inexperiente em PHP e também no Framework, eu não sei como buscar via código essa classificação grupo CLIENTE e de MECÂNICO, ou seja, não sei nestes campos (TDBUniqueSearch) como carregar somente a pessoa classificada como CLIENTE e MECÂNICO , respectivamente. Só reforçando, não quero "misturar" os grupos de pessoas nestes campos.


Cadastro de pessoas - esse é o campo em questão ($grupo_id = new TDBRadioGroup('grupo_id', 'oficina', 'Grupo', 'id', '{nome}','id asc' )): 


 
  1. <?php
  2. /**
  3.  * PessoaForm Form
  4.  */
  5. class PessoaForm extends TPage
  6. {
  7.     protected $form; // form
  8.     
  9.     /**
  10.      * Form constructor
  11.      * @param $param Request
  12.      */
  13.     public function __construct( $param )
  14.     {
  15.         parent::__construct();
  16.         
  17.         // creates the form
  18.         $this->form = new BootstrapFormBuilder('form_Pessoa');
  19.         $this->form->setFormTitle('Pessoas');
  21.         // create the form fields
  22.         $id          = new TEntry('id');
  23.         $nome        = new TEntry('nome');
  24.         $documento   = new TEntry('documento');
  25.         $documento2  = new TEntry('documento2');
  26.         $fone        = new TEntry('fone');
  27.         $celular     = new TEntry('celular');
  28.         $email       = new TEntry('email');
  29.         $rua         = new TEntry('rua');
  30.         $numero      = new TEntry('numero');
  31.         $bairro      = new TEntry('bairro');
  32.         $complemento = new TEntry('complemento');
  33.         $cep         = new TEntry('cep');
  34.         $obs         = new TEntry('obs');
  35.         $cidade_id   = new TDBCombo('cidade_id', 'oficina', 'Cidade', 'id', '{nome}','id asc'  );
  36.         $estado_id   = new TDBCombo('estado_id', 'oficina', 'Estado', 'id', '{uf}','id asc'  );
  37.         $grupo_id    = new TDBRadioGroup('grupo_id', 'oficina', 'Grupo', 'id', '{nome}','id asc'  );
  38.         $tipo_id     = new TDBRadioGroup('tipo_id', 'oficina', 'Tipo', 'id', '{nome}','id asc'  );
  39.         
  40.         $nome->addValidation('Nome', new TRequiredValidator());
  41.         $tipo_id->addValidation('Tipo', new TRequiredValidator()); 
  42.         $estado_id->addValidation('UF', new TRequiredValidator());
  43.         $cidade_id->addValidation('Cidade', new TRequiredValidator());
  44.         $grupo_id->addValidation('Grupo', new TRequiredValidator());
  45.      
  46.         $tipo_id->setLayout('horizontal');
  47.         $grupo_id->setLayout('horizontal');
  48.         $id->setEditable(false);
  50.         $id->setSize(60);
  51.         $rua->setSize('72%');
  52.         $cep->setSize('72%');
  53.         $nome->setSize('70%');
  54.         $fone->setSize('72%');
  55.         $celular->setSize('72%');
  56.         $email->setSize('72%');
  57.         $numero->setSize('72%');
  58.         $bairro->setSize('72%');
  59.         $obs->setSize('89%', 68);
  60.         $documento->setSize('72%');
  61.         $documento2->setSize('72%');
  62.         $estado_id->setSize('20%');
  63.         $cidade_id->setSize('72%');
  64.         $complemento->setSize('72%');
  65.         $tipo_id->setSize(80);
  66.         $grupo_id->setSize(200);
  67.         $nome->forceUpperCase();
  68.         $rua->forceUpperCase();
  69.         $bairro->forceUpperCase();
  70.         $complemento->forceUpperCase();
  71.         $email->forceLowerCase();
  72.         $documento->setMask('999.999.999-99'); 
  73.         $documento2->setMask('99.999.999/9999-99');
  74.         $fone->setMask('(99)9999-9999');
  75.         $celular->setMask('(99)9.9999-9999');
  76.         $cep->setMask('99.999-999');
  77.         $numero->setMask('99999999');
  78.         $id->setEditable(FALSE);  
  80.         // add the fields
  81.         $this->form->addFields([new TLabel('Tipo:', '#ff0000')],[$tipo_id], [new TLabel('Código:')],[$id]);
  82.         $this->form->addFields([new TLabel('Nome:', '#ff0000')],[$nome]);
  83.         $this->form->addFields([new TLabel('CPF:')],[$documento], [new TLabel('CNPJ:')],[$documento2]);
  84.         $this->form->addFields([new TLabel('Fone:')],[$fone], [new TLabel('Celular:')],[$celular] );
  85.         $this->form->addFields([new TLabel('Cep:')],[$cep],[new TLabel('Email:')],[$email]);
  86.         $this->form->addFields([new TLabel('Endereço:')],[$rua],[new TLabel('Numero:')],[$numero]);
  87.         $this->form->addFields([new TLabel('Cidade:', '#ff0000')],[$cidade_id], [new TLabel('UF:', '#ff0000')],[$estado_id]);
  88.         $this->form->addFields([new TLabel('Bairro:')],[$bairro], [new TLabel('Complemento:')],[$complemento] );     
  89.         $this->form->addFields([new TLabel('Obs:')],[$obs]);
  90.         $this->form->addFields([new TLabel('Grupo', '#ff0000')],[$grupo_id]);
  91.         
  92.         /* Ação de Habilita e Desabilita campo da Pessoa Física ou Jurídica */
  93.         $tipo_id->setChangeAction( new TAction( array($this, 'onChangeRadio')) );
  96.         if (!empty($id))
  97.         {
  98.             $id->setEditable(FALSE);
  99.         }
  100.         
  101.         /** samples
  102.          $this->form->addQuickFields('Date', array($date1, new TLabel('to'), $date2)); // side by side fields
  103.          $fieldX->addValidation( 'Field X', new TRequiredValidator ); // add validation
  104.          $fieldX->setSize( 100, 40 ); // set size
  105.          **/
  106.          
  107.         // create the form actions
  108.         $this->form->addAction('Salvar', new TAction([$this, 'onSave']), 'fa:floppy-o')->addStyleClass('btn-primary');
  109.         $this->form->addAction('Novo', new TAction([$this, 'onClear']), 'fa:plus-circle #69aa46');
  110.         $this->form->addAction(_t('Back'),new TAction(array('PessoaList','onReload')),'fa:arrow-circle-o-left blue');
  111.         
  112.         // vertical box container
  113.         $container = new TVBox;
  114.         $container->style = 'width: 100%';
  115.         $container->class = 'form-container';
  116.         $container->add(new TXMLBreadCrumb('menu.xml', 'PessoaList'));
  117.         $container->add($this->form);
  119.         parent::add($container);
  120.     }
  123.     /**
  124.      * Save form data
  125.      * @param $param Request
  126.      */
  127.     public function onSave( $param )
  128.     {
  129.         try
  130.         {
  131.             TTransaction::open('oficina'); // open a transaction
  132.             
  133.             /**
  134.             // Enable Debug logger for SQL operations inside the transaction
  135.             TTransaction::setLogger(new TLoggerSTD); // standard output
  136.             TTransaction::setLogger(new TLoggerTXT('log.txt')); // file
  137.             **/
  138.             
  139.             /*Valida o CPF - Está funcionando, só ligar se realmente o cliente quiser
  140.             if($param['tipo_id'] == 1 )
  141.             {                
  142.                 $validacpf = new TCPFValidator;
  143.                 $validacpf->validate('CPF', $param['documento']);  
  144.                 
  145.             }
  146.             
  147.             Valida o CNPJ
  148.             if($param['tipo_id'] == 2 )
  149.             {
  150.                 $validator = new TCNPJValidator;
  151.                 $validator->validate('CNPJ', $param['documento2']);
  152.                 
  153.             }
  154.             */
  155.             
  156.             $this->form->validate(); // validate form data
  157.             
  158.             $object = new Pessoa;  // create an empty object
  159.             $data = $this->form->getData(); // get form data as array
  160.             $object->fromArray( (array) $data); // load the object with data
  161.             $object->store(); // save the object
  162.             
  163.             // get the generated id
  164.             $data->id = $object->id;
  165.             
  166.             //Controle de passagem dos campos para o formulário da pessoa Física e Jurídica
  167.             $obj = new stdClass;
  168.             $obj->tipo_id     = $object->tipo_id;
  169.             $obj->estado_id   = $object->estado_id;
  170.             $obj->documento   = $object->documento;
  171.             $obj->documento2  = $object->documento2;
  172.             
  173.             self::onChangeRadio(['tipo_id'=>$object->tipo_id]); 
  174.             TForm::sendData('form_Pessoa', $obj);
  175.             
  176.             $this->form->setData($data); // fill form data
  177.             TTransaction::close(); // close the transaction
  178.             
  179.             new TMessage('info', TAdiantiCoreTranslator::translate('Record saved'));
  180.         }
  181.         catch (Exception $e) // in case of exception
  182.         {
  183.             new TMessage('error', $e->getMessage()); // shows the exception error message
  184.             $this->form->setData( $this->form->getData() ); // keep form data
  185.             TTransaction::rollback(); // undo all pending operations
  186.         }
  187.     }
  188.     
  189.     /**
  190.      * Clear form data
  191.      * @param $param Request
  192.      */
  193.     public function onClear( $param )
  194.     {
  195.         $this->form->clear(TRUE);
  196.     }
  197.     
  198.     /**
  199.      * Load object to form data
  200.      * @param $param Request
  201.      */
  202.     public function onEdit( $param )
  203.     {
  204.         try
  205.         {
  206.             if (isset($param['key']))
  207.             {
  208.                 $key = $param['key'];  // get the parameter $key
  209.                 TTransaction::open('oficina'); // open a transaction
  210.                 $object = new Pessoa($key); // instantiates the Active Record
  211.                 $this->form->setData($object); // fill the form
  212.                 TTransaction::close(); // close the transaction
  213.                 
  214.                 //Controle de passagem dos campos para o formulário da pessoa Física e Jurídica
  215.                 $obj = new stdClass;
  216.                 $obj->tipo_id     = $object->tipo_id;
  217.                 $obj->estado_id   = $object->estado_id;
  218.                 $obj->documento   = $object->documento;
  219.                 $obj->documento2  = $object->documento2;
  220.                 
  221.                 self::onChangeRadio(['tipo_id'=>$object->tipo_id]); 
  222.                 TForm::sendData('form_Pessoa', $obj);
  223.                 
  224.             }
  225.             else
  226.             {
  227.                 $this->form->clear(TRUE);
  228.             }
  229.         }
  230.         catch (Exception $e) // in case of exception
  231.         {
  232.             new TMessage('error', $e->getMessage()); // shows the exception error message
  233.             TTransaction::rollback(); // undo all pending operations
  234.         }
  235.     }
  236.     
  237.     /**
  238.      * on ChangeRadio change
  239.      * @param $param Action parameters
  240.      */
  241.     public static function onChangeRadio($param)
  242.     {
  243.         if ($param['tipo_id'] == 1)
  244.         {
  245.             TEntry::enableField('form_Pessoa', 'documento');
  246.             
  247.             TEntry::disableField('form_Pessoa', 'documento2');
  248.             TEntry::clearField('form_Pessoa', 'documento2');
  249.             
  250.         }
  251.         
  252.         if ($param['tipo_id'] == 2)
  253.         {
  254.             TEntry::enableField('form_Pessoa', 'documento2');
  255.             
  256.             TEntry::disableField('form_Pessoa', 'documento');
  257.             TEntry::clearField('form_Pessoa', 'documento');
  258.             
  259.         }
  260.     }
  261. }
  262. ?>



Cadastro de Ordem de Serviço - é neste código que não sei como implementar:
Esses campos são os envolvidos:
$cliente_id = new TDBUniqueSearch('cliente_id', 'oficina', 'Pessoa', 'id', 'nome','nome asc' )
$item_pedido_mecanico_id = new TDBUniqueSearch('item_pedido_mecanico_id', 'oficina', 'Pessoa', 'id', 'nome','id asc' ) 


 
  1. <?php
  2. /**
  3.  * PedidoForm Form
  4.  */
  5. class PedidoForm extends TPage
  6. {
  7.     protected $form; // form
  8.     
  9.     use adianti\base\AdiantiMasterDetailTrait;
  10.     
  11.     /**
  12.      * Form constructor
  13.      * @param $param Request
  14.      */
  15.     public function __construct( $param )
  16.     {
  17.         parent::__construct();
  18.         
  19.         $this->form = new BootstrapFormBuilder('list_Pedido');
  20.         $this->form->setFormTitle('Ordem de Serviço');
  22.         // Definição dos campos da tela Master
  23.         $id                     = new TEntry('id');
  24.         $estado_pedido_id       = new TDBCombo('estado_pedido_id', 'oficina', 'EstadoPedido', 'id', 'nome','id asc'  );
  25.         $cliente_id             = new TDBUniqueSearch('cliente_id', 'oficina', 'Pessoa', 'id', 'nome','nome asc'  );
  26.         $dt_pedido              = new TDate('dt_pedido');
  27.         $obs                    = new TText('obs');
  28.         
  29.         // Definição dos campos da tela Detalhe (itens da ordem de serviço)
  30.         $item_pedido_mecanico_id = new TDBUniqueSearch('item_pedido_mecanico_id', 'oficina', 'Pessoa', 'id', 'nome','id asc' );
  31.         $item_pedido_produto_id  = new TDBUniqueSearch('item_pedido_produto_id', 'oficina', 'Produto', 'id', 'nome','id asc' );
  32.         $item_pedido_quantidade  = new TNumeric('item_pedido_quantidade', '2', ',', '.' );
  33.         $item_pedido_valor       = new TNumeric('item_pedido_valor', '2', ',', '.' );
  34.         $item_pedido_id          = new THidden('item_pedido_id');
  36.         $estado_pedido_id->addValidation('Estado pedido', new TRequiredValidator());
  37.         $cliente_id->addValidation('Cliente', new TRequiredValidator());
  39.         $id->setEditable(false);
  40.         $id->setSize(100);
  41.         $cliente_id->setMinLength(1);
  42.         $cliente_id->setSize('100%');
  43.         $item_pedido_mecanico_id->setMinLength(1);
  44.         $item_pedido_produto_id->setMinLength(1);
  45.         $dt_pedido->setValue(date('d/m/Y h:i'));
  46.         $dt_pedido->setDatabaseMask('yyyy-mm-dd');
  47.         $cliente_id->setMask('{nome}');
  48.         $dt_pedido->setMask('dd/mm/yyyy');
  49.         $dt_pedido->setSize(190);
  50.         $obs->setSize('90%', 68);
  51.         $estado_pedido_id->setSize('75%');
  52.         $item_pedido_valor->setSize('20%');
  53.         $item_pedido_mecanico_id->setMask('{nome}');
  54.         $item_pedido_mecanico_id->setSize('75%');
  55.         $item_pedido_produto_id->setMask('{nome}');
  56.         $item_pedido_produto_id->setSize('20%');
  57.         $item_pedido_quantidade->setSize('21%');
  58.         
  59.         // Adicionando os campos da tela Master
  60.         $this->form->addFields([new TLabel('Nro O.S:')],[$id],[new TLabel('Status:', '#ff0000')],[$estado_pedido_id]);
  61.         $this->form->addFields([new TLabel('Cliente:', '#ff0000')],[$cliente_id],[new TLabel('Data OS:')],[$dt_pedido]);
  62.         $this->form->addFields([new TLabel('Obs:')],[$obs]);
  63.         
  64.         // Adicionando os campos da tela Detalhe (itens da ordem de serviço)
  65.         $this->form->addContent([new TFormSeparator('Itens da O.S', '#333333', '18', '#eeeeee')]);
  66.         $this->form->addFields([new TLabel('Mecânico:', '#ff0000')],[$item_pedido_mecanico_id]);
  67.         $this->form->addFields([new TLabel('Produto:', '#ff0000')],[$item_pedido_produto_id]);
  68.         $this->form->addFields([new TLabel('Quantidade:')],[$item_pedido_quantidade]);
  69.         $this->form->addFields([new TLabel('Valor:')],[$item_pedido_valor]);
  70.         $this->form->addFields([$item_pedido_id]);         
  71.         
  72.         // Criando o botão Adicionar (que inclui os itens [detalhes] na datagrid
  73.         $add_item_pedido = new TButton('add_item_pedido');
  74.         $add_item_pedido->setAction(new TAction(array($this, 'onAddItemPedido')), 'Adicionar');
  75.         $add_item_pedido->setImage('fa:plus #51c249');
  76.         $this->form->addFields([$add_item_pedido]);
  77.         
  78.         
  79.         // Definição da Datagrid
  80.         $this->item_pedido_list = new BootstrapDatagridWrapper(new TQuickGrid);
  81.         $this->item_pedido_list->style = 'width:100%';
  82.         $this->item_pedido_list->class .= ' table-bordered';
  83.         $this->item_pedido_list->disableDefaultClick();
  84.         $this->item_pedido_list->addQuickColumn('', 'edit', 'left', 50);
  85.         $this->item_pedido_list->addQuickColumn('', 'delete', 'left', 50);
  86.         
  87.         
  88.         $col_mecanico_id       = $this->item_pedido_list->addQuickColumn('Mecânico', 'item_pedido_mecanico_id', 'left');
  89.         $col_produto_id        = $this->item_pedido_list->addQuickColumn('Produto', 'item_pedido_produto_id', 'left');
  90.         $col_quantidade        = $this->item_pedido_list->addQuickColumn('Quantidade', 'item_pedido_quantidade', 'left');
  91.         $col_valor             = $this->item_pedido_list->addQuickColumn('Valor', 'item_pedido_valor', 'right');
  92.         $col_total             = $this->item_pedido_list->addQuickColumn('Total', '= {item_pedido_quantidade} * {item_pedido_valor}', 'right');
  93.         
  94.         $col_total->setTotalFunction( function($values) { 
  95.             return array_sum((array) $values);
  96.         }); 
  97.         
  98.         $this->item_pedido_list->createModel();
  99.         
  100.         $col_total->setTransformer(function($value, $object, $row) {
  101.             if (!$value)
  102.             {
  103.                 $value = 0;
  104.             }
  105.             return "R$ " . number_format($value, 2, ",", ".");
  106.         });
  107.         
  108.         $this->form->addContent([$this->item_pedido_list]);
  109.         
  110.         // Cria as ações do Formulário
  111.         $this->form->addAction('Salvar', new TAction([$this, 'onSave']), 'fa:floppy-o')->addStyleClass('btn-primary');
  112.         $this->form->addAction('Limpar formulário', new TAction([$this, 'onClear']), 'fa:eraser #dd5a43');
  113.         $this->form->addAction(_t('Back'),new TAction(array('PedidoList','onReload')),'fa:arrow-circle-o-left blue');
  115.         // Controle da caixa vertical de todo o formulário
  116.         $container = new TVBox;
  117.         $container->style = 'width: 100%';
  118.         $container->class = 'form-container';
  119.         $container->add(new TXMLBreadCrumb('menu.xml', 'PedidoList'));
  120.         $container->add($this->form);
  121.         
  122.         parent::add($container);
  124.     }
  125.     
  126.     /**
  127.      * Adiciona item ao pedido
  128.      * @param $param Request
  129.      */
  130.     public function onAddItemPedido( $param )
  131.     {
  132.         try
  133.         {
  134.             $data = $this->form->getData();
  136.             if(!$data->item_pedido_produto_id)
  137.             {
  138.                 throw new Exception(AdiantiCoreTranslator::translate('The field ^1 is required', 'Produto id'));
  139.             }
  140.             
  141.             $item_pedido_items = TSession::getValue('item_pedido_items'); // faz leitura da variável de seção
  142.             
  143.             $key = !empty($data->item_pedido_id) ? $data->item_pedido_id : uniqid();
  144.             
  145.             $fields = []; 
  146.             $fields['item_pedido_produto_id']  = $data->item_pedido_produto_id;
  147.             $fields['item_pedido_mecanico_id'] = $data->item_pedido_mecanico_id; // Minha modificação p/ o mecânico
  148.             $fields['item_pedido_quantidade']  = $data->item_pedido_quantidade;
  149.             $fields['item_pedido_valor']       = $data->item_pedido_valor;
  150.             $item_pedido_items[ $key ]         = $fields;
  151.             
  152.             TSession::setValue('item_pedido_items', $item_pedido_items);
  154.             // limpa os campos do item do pedido
  155.             $data->item_pedido_mecanico_id = ''; // Minha modificação p/ o mecânico
  156.             $data->item_pedido_produto_id = '';
  157.             $data->item_pedido_quantidade = '';
  158.             $data->item_pedido_valor = '';
  159.             $data->item_pedido_id = '';
  160.             
  161.             $this->form->setData($data);
  162.             $this->onReload( $param );
  163.         }
  164.         catch (Exception $e)
  165.         {
  166.             $this->form->setData( $this->form->getData());
  167.             new TMessage('error', $e->getMessage());
  168.         }
  169.     }
  171.     /**
  172.      * Recarrega tudo
  173.      * @param $param Request
  174.      */
  175.     public function onReload($params = null)
  176.     {
  177.         $this->loaded = TRUE;
  178.         $this->onReloadPedidoItemPedido($params);
  179.     }
  180.     
  181.     /**
  182.      * Recarrega itens do pedido
  183.      * @param $param Request
  184.      */
  185.     public function onReloadPedidoItemPedido( $param )
  186.     {
  187.         $items = TSession::getValue('item_pedido_items');
  189.         $this->item_pedido_list->clear(); 
  191.         if($items) 
  192.         { 
  193.             $cont = 1; 
  194.             foreach ($items as $key => $item) 
  195.             {
  196.                 $rowItem = new StdClass;
  198.                 $action_del = new TAction(array($this, 'onDeleteItemPedido')); 
  199.                 $action_del->setParameter('item_pedido_id_row_id', $key);   
  201.                 $action_edi = new TAction(array($this, 'onEditItemPedido'));  
  202.                 $action_edi->setParameter('item_pedido_id_row_id', $key);  
  204.                 $button_del = new TButton('delete_item_pedido'.$cont);
  205.                 $button_del->class = 'btn btn-default btn-sm';
  206.                 $button_del->setAction($action_del, '');
  207.                 $button_del->setImage('fa:trash-o'); 
  208.                 $button_del->setFormName($this->form->getName());
  210.                 $button_edi = new TButton('edit_item_pedido'.$cont);
  211.                 $button_edi->class = 'btn btn-default btn-sm';
  212.                 $button_edi->setAction($action_edi, '');
  213.                 $button_edi->setImage('bs:edit');
  214.                 $button_edi->setFormName($this->form->getName());
  216.                 $rowItem->edit   = $button_edi;
  217.                 $rowItem->delete = $button_del;
  218.                 
  219.                 $rowItem->item_pedido_produto_id = '';
  220.                 
  221.                 if (isset($item['item_pedido_produto_id']) && $item['item_pedido_produto_id'])
  222.                 {
  223.                     TTransaction::open('oficina');
  224.                     $produto = Produto::find($item['item_pedido_produto_id']);
  225.                     $rowItem->item_pedido_produto_id = $produto->render('{nome}');
  226.                     TTransaction::close();
  227.                 }
  228.                 
  229.                 // Minha modificação p/ o mecânico - linha logo abaixo
  230.                 $rowItem->item_pedido_mecanico_id = isset($item['item_pedido_mecanico_id']) ? $item['item_pedido_mecanico_id'] : '';
  231.                 $rowItem->item_pedido_quantidade  = isset($item['item_pedido_quantidade'])  ? $item['item_pedido_quantidade'] : '';
  232.                 $rowItem->item_pedido_valor       = isset($item['item_pedido_valor'])       ? $item['item_pedido_valor'] : '';
  234.                 $this->item_pedido_list->addItem($rowItem);
  235.                 $cont ++;
  236.             } 
  237.         } 
  238.     } 
  239.     
  240.     /**
  241.      * Edita item do pedido
  242.      * @param $param Request
  243.      */
  244.     public function onEditItemPedido( $param )
  245.     {
  246.         $data = $this->form->getData();
  248.         // read session items
  249.         $items = TSession::getValue('item_pedido_items'); 
  251.         // get the session item
  252.         $item = $items[$param['item_pedido_id_row_id']];
  254.         $data->item_pedido_produto_id  = $item['item_pedido_produto_id'];
  255.         $data->item_pedido_mecanico_id = $item['item_pedido_mecanico_id']; // Minha modificação p/ o mecânico
  256.         $data->item_pedido_quantidade  = $item['item_pedido_quantidade'];
  257.         $data->item_pedido_valor       = $item['item_pedido_valor'];
  258.         $data->item_pedido_id          = $param['item_pedido_id_row_id'];
  259.         
  260.         // fill product fields
  261.         $this->form->setData( $data );
  263.         $this->onReload( $param );
  264.     }
  265.     
  266.     /**
  267.      * Exclui item do pedido
  268.      * @param $param Request
  269.      */
  270.     public function onDeleteItemPedido( $param )
  271.     {
  272.         $data = $this->form->getData();
  274.         $data->item_pedido_mecanico_id = ''; // Minha modificação p/ o mecânico
  275.         $data->item_pedido_produto_id = '';
  276.         $data->item_pedido_quantidade = '';
  277.         $data->item_pedido_valor      = '';
  278.         $this->form->setData( $data );
  280.         // read session items
  281.         $items = TSession::getValue('item_pedido_items');
  283.         // delete the item from session
  284.         unset($items[$param['item_pedido_id_row_id']]);
  285.         TSession::setValue('item_pedido_items', $items);
  286.         
  287.         $this->onReload( $param );
  288.     }
  290.     /**
  291.      * Limpa formulário
  292.      * @param $param Request
  293.      */
  294.     public function onClear( $param )
  295.     {
  296.         $this->form->clear();
  297.         TSession::setValue('item_pedido_items', null);
  298.         $this->onReload();
  299.     }
  300.     
  301.     /**
  302.      * Salva pedido
  303.      * @param $param Request
  304.      */
  305.     public function onSave($param = null) 
  306.     {
  307.         try
  308.         {
  309.             TTransaction::open('oficina');
  310.             
  311.             $this->form->validate();
  312.             $data = $this->form->getData();
  313.             
  314.             $object = new Pedido; 
  315.             $object->fromArray( (array) $data);
  316.             $object->store(); 
  317.             
  318.             $this->storeItems('PedidoItem', 'pedido_id', $object, 'item_pedido',
  319.                 function($masterObject, $detailObject) { 
  320.                     $masterObject->valor_total += ($detailObject->quantidade * $detailObject->valor);
  321.             });
  322.             $object->store();
  324.             $data->id = $object->id; 
  325.             $this->form->setData($data);
  326.             TTransaction::close();
  327.             
  328.             new TMessage('info', AdiantiCoreTranslator::translate('Record saved'));
  329.         }
  330.         catch (Exception $e)
  331.         {
  332.             new TMessage('error', $e->getMessage());
  333.             $this->form->setData( $this->form->getData() );
  334.             TTransaction::rollback();
  335.         }
  336.     }
  337.     
  338.     /**
  339.      * Edita formulário
  340.      * @param $param Request
  341.      */
  342.     public function onEdit( $param )
  343.     {
  344.         try
  345.         {
  346.             if (isset($param['key']))
  347.             {
  348.                 $key = $param['key'];
  349.                 TTransaction::open('oficina');
  350.                 
  351.                 $object = new Pedido($key); 
  352.                 $this->loadItems('PedidoItem', 'pedido_id', $object, 'item_pedido');
  353.                  
  354.                 $this->form->setData($object); 
  355.                 $this->onReload();
  356.                 TTransaction::close(); 
  357.             }
  358.             else
  359.             {
  360.                 $this->form->clear();
  361.             }
  362.         }
  363.         catch (Exception $e)
  364.         {
  365.             new TMessage('error', $e->getMessage());
  366.             TTransaction::rollback();
  367.         }
  368.     }
  369.     
  370.     /**
  371.      * Exibe a página
  372.      * @param $param Request
  373.      */
  374.     public function show() 
  375.     { 
  376.         if (!$this->loaded AND (!isset($_GET['method']) OR $_GET['method'] !== 'onReload') ) 
  377.         { 
  378.             $this->onReload( func_get_arg(0) );
  379.         }
  380.         parent::show();
  381.     }
  382. }
  383. ?>

Curso Dominando o Adianti Framework

O material mais completo de treinamento do Framework.
Curso em vídeo aulas + Livro completo + Códigos fontes do projeto ERPHouse.
Conteúdo Atualizado!


Dominando o Adianti Framework Quero me inscrever agora!

Comentários (2)

NR
Nataniel Rabaioli       28/11/2017 (há 7 anos)

O componente TDBUniqueSearch possui mais um parâmetro, onde você pode informar o filtro(tcriteria) que deseja utilizar: 
 
  1. <?php
  2. // class TDBUniqueSearch
  3. public function __construct($name, $database, $model, $key, $value, $orderColumn = NULL, TCriteria $criteria = NULL)
  5. $crit = new TCriteria();
  6. $crit->add(new TFilter('grupo_id','=',$id_do_grupo_desejado));
  7. $cliente_id = new TDBUniqueSearch('cliente_id', 'oficina', 'Pessoa', 'id', 'nome','nome asc', $crit );
  8. ?>
HB
Humberto Vilas Boas - AUTOR DO POST       28/11/2017 (há 7 anos)

Nataniel, fiz conforme recomendado e deu certo tanto para cliente quanto para o mecânico .

Obrigado.