<?php
/**
 * SysDevolucao Listing
 * @package    biblioteca
 * @version    5.19.562 ( 28/03/2019 )
 * @framework  Adianti Studio Pro 5.6
 */
class SysDevolucao extends TPage
{
    private $form; // form
    private $datagrid; // listing
    private $pageNavigation;
    private $formgrid;
    private $loaded;
    private $deleteButton;
    
    /**
     * Class constructor
     * Creates the page, the form and the listing
     */
    public function __construct()
    {
        parent::__construct();
        
        // creates the form
        $this->form = new TQuickForm('form_search_SysRetiradasAcervo');
        $this->form->class = 'tform'; // change CSS class
        
        $this->form->style = 'display: table;width:100%'; // change style
        $this->form->setFormTitle('EMPRÉSTIMO / RENOVA / DEVOLVE');
        // create the form fields
        $Tbr_idregistro = new TSeekButton('Tbr_idregistro');
        $Tbr_titulo     = new TEntry('Tbr_titulo');
        $Tbr_idusuario  = new TSeekButton('Tbr_idusuario');
        $Tbr_nmusuario  = new TEntry('Tbr_nmusuario');
        $Tbr_retini     = new TDate('Tbr_retini');
        $Tbr_retfin     = new TDate('Tbr_retfin');
        $Tbr_devini     = new TDate('Tbr_devini');
        $Tbr_devfin     = new TDate('Tbr_devfin');
        $Tbr_idregistro->setAction( new TAction(array( 'SeekAcervoDevList', 'onReload' )));
        $Tbr_idusuario->setAction( new TAction(array( 'SeekUsuarioRetList', 'onReload' )));
        $Tbr_titulo->setEditable(FALSE);
        $Tbr_nmusuario->setEditable(FALSE);
        $Tbr_idregistro->setSize(100);
        $Tbr_titulo->setSize(400);
        $Tbr_idusuario->setSize(100);
        $Tbr_nmusuario->setSize(400);
        
        $Tbr_retini->setSize(95);   
        $Tbr_retini->setMask('dd/mm/yyyy');
        $Tbr_retini->setDatabaseMask('yyyy-mm-dd');
        
        $Tbr_retfin->setSize(95);
        $Tbr_retfin->setMask('dd/mm/yyyy');
        $Tbr_retfin->setDatabaseMask('yyyy-mm-dd');
        $Tbr_devini->setSize(95);
        $Tbr_devini->setMask('dd/mm/yyyy');
        $Tbr_devini->setDatabaseMask('yyyy-mm-dd');
        $Tbr_devfin->setSize(95);      
        $Tbr_devfin->setMask('dd/mm/yyyy');
        $Tbr_devfin->setDatabaseMask('yyyy-mm-dd');
        // add the fields       
        $this->form->addQuickFields('REGISTRO',  array($Tbr_idregistro, $Tbr_titulo));
        $this->form->addQuickFields('USUARIO',   array($Tbr_idusuario,  $Tbr_nmusuario));
        $this->form->addQuickFields('RETIRADA >> <<',  array($Tbr_retini, $Tbr_retfin));
        $this->form->addQuickFields('DEVOLUCAO >> <<', array($Tbr_devini, $Tbr_devfin));
        
        // keep the form filled during navigation with session data
        $this->form->setData( TSession::getValue('SysRetiradaAcervo_filter_data') );
        
        // add the search form actions
        $this->form->addQuickAction('BUSCA',    new TAction(array($this, 'onSearch')),   'fa:search');
        $this->form->addQuickAction('NOVO',     new TAction(array('SysRetiradaAcervo',   'onEdit')), 'bs:plus-sign green');
        $this->form->addQuickAction('ACERVO',   new TAction(array('SysAcervoConsulta',   'onReload')), 'fa:book');
        $this->form->addQuickAction('USUARIOS', new TAction(array('TbUsuarioLista',      'onReload')), 'fa:user');
        $this->form->addQuickAction('MULTAS',   new TAction(array('SysMultasBaixaLista', 'onReload')), 'fa:credit-card');
        $this->form->addQuickAction('RECIBOS',  new TAction(array('SysRecibosLista',     'onReload')), 'fa:usd');
        
        // creates a Datagrid
        $this->datagrid = new TDataGrid;
        
        $this->datagrid->style = 'width: 100%';
        $this->datagrid->datatable = 'true';
        // $this->datagrid->enablePopover('Popover', 'Hi <b> {name} </b>');
        
        // creates the datagrid columns
        $column_Tbr_idcontrole  = new TDataGridColumn('Tbr_idcontrole',  'ID',        'center');
        $column_Tbr_idregistro  = new TDataGridColumn('Tbr_idregistro',  'ACERVO',    'center');
        $column_Tbr_titulo      = new TDataGridColumn('tb_acervo_cons->Tba_titulo', 'TITULO', 'left', 200);
        $column_Tbr_idusuario   = new TDataGridColumn('Tbr_idusuario',   'USER',      'center');
        $column_Tbr_leitor      = new TDataGridColumn('tb_usuario->Tbu_nome', 'NOME', 'left');
        $column_Tbr_retirada    = new TDataGridColumn('Tbr_retirada',    'RETIRADA',  'center');
        $column_Tbr_devolucao   = new TDataGridColumn('Tbr_devolucao',   'DEVOLVER',  'center');
        $column_Tbr_devolvido   = new TDataGridColumn('Tbr_devolvido',   'DEVOLVIDO', 'center');
        $column_Tbr_renovado    = new TDataGridColumn('Tbr_renovado',    'RNV',       'center');
 
        $column_Tbr_renovado->setTransformer( function($value, $object, $row) {
            $class = ($value < 1) ? 'danger' : 'success';
            $label = ($value < 1) ? '' : $value;
            $div = new TElement('span');
            $div->class="label label-{$class}";
            $div->style="text-shadow:none; font-size:12px; font-weight:lighter";
            $div->add($label);
            return $div;
        });
        // define data no formato br, apenas para o registros pagos
        $column_Tbr_devolvido->setTransformer( function($value, $object, $row) {
                if ($value)
                {
                    $date = new DateTime($value);
                    return $date->format('d/m/Y');
                }
            });
        // add the columns to the DataGrid
        $this->datagrid->addColumn($column_Tbr_idcontrole);
        $this->datagrid->addColumn($column_Tbr_idregistro);
        $this->datagrid->addColumn($column_Tbr_titulo);
        $this->datagrid->addColumn($column_Tbr_idusuario);
        $this->datagrid->addColumn($column_Tbr_leitor);
        $this->datagrid->addColumn($column_Tbr_retirada);
        $this->datagrid->addColumn($column_Tbr_devolucao);
        $this->datagrid->addColumn($column_Tbr_devolvido);
        $this->datagrid->addColumn($column_Tbr_renovado);
        // creates the datagrid column actions
        $order_Tbr_idregistro = new TAction(array($this, 'onReload'));
        $order_Tbr_idregistro->setParameter('order', 'Tbr_idregistro');
        $column_Tbr_idregistro->setAction($order_Tbr_idregistro);
        
        $order_Tbr_idusuario = new TAction(array($this, 'onReload'));
        $order_Tbr_idusuario->setParameter('order', 'Tbr_idusuario');
        $column_Tbr_idusuario->setAction($order_Tbr_idusuario);
        
        $order_Tbr_retirada = new TAction(array($this, 'onReload'));
        $order_Tbr_retirada->setParameter('order', 'Tbr_retirada');
        $column_Tbr_retirada->setAction($order_Tbr_retirada);
        
        $order_Tbr_devolucao = new TAction(array($this, 'onReload'));
        $order_Tbr_devolucao->setParameter('order', 'Tbr_devolucao');
        $column_Tbr_devolucao->setAction($order_Tbr_devolucao);
        
        // define the transformer method over image
        $column_Tbr_retirada->setTransformer( function($value, $object, $row) {
            $date = new DateTime($value);
            return $date->format('d/m/Y');
        });
        // define the transformer method over image
        $column_Tbr_devolucao->setTransformer( function($value, $object, $row) {
            $date = new DateTime($value);
            return $date->format('d/m/Y');
        });
        
        // create EDIT action
        $action_edit = new TDataGridAction(array('SysRetiradaAcervo', 'onEdit'));
        $action_edit->setButtonClass('btn btn-default');
        $action_edit->setLabel(_t('Edit'));
        $action_edit->setImage('fa:pencil-square-o blue fa-lg');
        $action_edit->setField('Tbr_idcontrole');
        // $this->datagrid->addAction($action_edit);
        
        // create RENOVA action
        $action_ren = new TDataGridAction(array($this, 'onRenova'));
        $action_ren->setButtonClass('btn btn-default');
        $action_ren->setLabel('RENOVAR');
        $action_ren->setImage('fa:refresh orange fa-lg');
        $action_ren->setField('Tbr_idcontrole');
        $this->datagrid->addAction($action_ren);
        //$action_ren->setDisplayCondition( array($this, 'verificaRenovacao') );
 
         // create DEVOLVE action
        $action_devo = new TDataGridAction(array($this, 'onDevolve'));
        $action_devo->setButtonClass('btn btn-default');
        $action_devo->setLabel('DEVOLVER');
        $action_devo->setImage('fa:book fa-lg');
        $action_devo->setField('Tbr_idcontrole');
//      $action_devo->setDisplayCondition( array($this, 'displayColumn') );
        $this->datagrid->addAction($action_devo);
    
        // create the datagrid model
        $this->datagrid->createModel();
        
        // creates the page navigation
        $this->pageNavigation = new TPageNavigation;
        $this->pageNavigation->setAction(new TAction(array($this, 'onReload')));
        $this->pageNavigation->setWidth($this->datagrid->getWidth());
        // vertical box container
        $container = new TVBox;
        $container->style = 'width: 100%';
        $container->add(new TXMLBreadCrumb('menu.xml', __CLASS__));
        $container->add($this->form);
        $container->add($this->datagrid);
        $container->add($this->pageNavigation);
        
        parent::add($container);
    }
    
    /**
     * Inline record editing
     * @param $param Array containing:
     *              key: object ID value
     *              field name: object attribute to be updated
     *              value: new attribute content 
     */
    public function onInlineEdit($param)
    {
        try
        {
            // get the parameter $key
            $field = $param['field'];
            $key   = $param['key'];
            $value = $param['value'];
            
            TTransaction::open('biblioteca'); // open a transaction with database
            $object = new SysRetiradasAcervo($key); // instantiates the Active Record
            $object->{$field} = $value;
            $object->store(); // update the object in the database
            TTransaction::close(); // close the transaction
            
            $this->onReload($param); // reload the listing
            new TMessage('info', "Registro atualizado");
        }
        catch (Exception $e) // in case of exception
        {
            new TMessage('error', '<b>Error</b> ' . $e->getMessage()); // shows the exception error message
            TTransaction::rollback(); // undo all pending operations
        }
    }
    
    /**
     * Register the filter in the session
     */
    public function onSearch()
    {
        // get the search form data
        $data = $this->form->getData();
        
        // clear session filters
        TSession::setValue('SysRetiradaAcervoLista_filter_Tbr_idregistro', NULL);
        TSession::setValue('SysRetiradaAcervoLista_filter_Tbr_idusuario',  NULL);
        TSession::setValue('SysRetiradaAcervoLista_filter_Tbr_retirada',   NULL);
        TSession::setValue('SysRetiradaAcervoLista_filter_Tbr_devolucao',  NULL);
        if (isset($data->Tbr_idregistro) AND ($data->Tbr_idregistro)) {
            $filter = new TFilter('Tbr_idregistro', '=', "$data->Tbr_idregistro"); // create the filter
            TSession::setValue('SysRetiradaAcervoLista_filter_Tbr_idregistro',   $filter); // stores the filter in the session
        }
        if (isset($data->Tbr_idusuario) AND ($data->Tbr_idusuario)) {
            $filter = new TFilter('Tbr_idusuario', '=', "$data->Tbr_idusuario"); // create the filter
            TSession::setValue('SysRetiradaAcervoLista_filter_Tbr_idusuario',   $filter); // stores the filter in the session
        }
        if ($data->Tbr_retini AND $data->Tbr_retini) {
            $filter = new TFilter('Tbr_retirada', 'between', $data->Tbr_retini, $data->Tbr_retfin); // create the filter
            TSession::setValue('SysRetiradaAcervoLista_filter_Tbr_retirada',   $filter); // stores the filter in the session
        }
        if ($data->Tbr_devini AND $data->Tbr_devfin) {
            $filter = new TFilter('Tbr_devolucao', 'between', $data->Tbr_devini, $data->Tbr_devfin); // create the filter
            TSession::setValue('SysRetiradaAcervoLista_filter_Tbr_devolucao',   $filter); // stores the filter in the session
        }
        
        // fill the form with data again
        $this->form->setData($data);
        
        // keep the search data in the session
        TSession::setValue('SysRetiradaAcervo_filter_data', $data);
        
        $param=array();
        $param['offset']    =0;
        $param['first_page']=1;
        $this->onReload($param);
    }
 
    /**
     * Display column conditional
     */
    public function displayColumn( $object )
    {
        if ($data->Tbr_devolvido)
        {
            return FALSE;
        }
        return TRUE;
    }
 
    
    /**
     * Load the datagrid with data
     */
    public function onReload($param = NULL)
    {
        try
        {
            // open a transaction with database 'biblioteca'
            TTransaction::open('biblioteca');
            
            // creates a repository for SysRetiradasAcervo
            $repository = new TRepository('SysRetiradasAcervo');
            $limit = 20;
            // creates a criteria
            $criteria = new TCriteria;
            $criteria->add(new TFilter('Tbr_devolvido', 'IS', NULL));
 <b>            
            // default order
            if (empty($param['order']))
            {
                $param['order'] = 'Tbr_idcontrole';    
            }
            if (empty($param['direction']))
            {
                $param['direction'] = 'desc';
            }
 </b>
            $criteria->setProperties($param); // order, offset
            $criteria->setProperty('limit', $limit);
            
            if (TSession::getValue('SysRetiradaAcervoLista_filter_Tbr_idregistro')) {
                $criteria->add(TSession::getValue('SysRetiradaAcervoLista_filter_Tbr_idregistro')); // add the session filter
            }
            if (TSession::getValue('SysRetiradaAcervoLista_filter_Tbr_idusuario')) {
                $criteria->add(TSession::getValue('SysRetiradaAcervoLista_filter_Tbr_idusuario')); // add the session filter
            }
            if (TSession::getValue('SysRetiradaAcervoLista_filter_Tbr_retirada')) {
                $criteria->add(TSession::getValue('SysRetiradaAcervoLista_filter_Tbr_retirada')); // add the session filter
            }
            if (TSession::getValue('SysRetiradaAcervoLista_filter_Tbr_devolucao')) {
                $criteria->add(TSession::getValue('SysRetiradaAcervoLista_filter_Tbr_devolucao')); // add the session filter
            }
            
            // 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) // in case of exception
        {
            // shows the exception error message
            new TMessage('error', $e->getMessage());
            // undo all pending operations
            TTransaction::rollback();
        }
    }
    
    /**
     * Ask before deletion
     */
    public function onDelete($param)
    {
        // define the delete action
        $action = new TAction(array($this, 'Delete'));
        $action->setParameters($param); // pass the key parameter ahead
        
        // shows a dialog to the user
        new TQuestion(AdiantiCoreTranslator::translate('Do you really want to delete ?'), $action);
    }
    
    /**
     * Delete a record
     */
    public function Delete($param)
    {
        try
        {
            $key=$param['key']; // get the parameter $key
            TTransaction::open('biblioteca'); // open a transaction with database
            $object = new SysRetiradasAcervo($key, FALSE); // instantiates the Active Record
            $object->delete(); // deletes the object from the database
            TTransaction::close(); // close the transaction
            $this->onReload( $param ); // reload the listing
            new TMessage('info', AdiantiCoreTranslator::translate('Record deleted')); // success message
        }
        catch (Exception $e) // in case of exception
        {
            new TMessage('error', $e->getMessage()); // shows the exception error message
            TTransaction::rollback(); // undo all pending operations
        }
    }
   
 
     /**
     * Ask before renewing
     */
    public function onRenova($param)
    {
        // define the delete action
        $action = new TAction(array($this, 'Renova'));
        $action->setParameters($param); // pass the key parameter ahead
        
        // shows a dialog to the user
        new TQuestion(('Confirma RENOVAÇÃO do Acervo ?'), $action);
    }
 
    /**
     * Renewing acervo
     */
    public function Renova($param)
    {
        try
        {
            $key=$param['key']; // get the parameter $key
            TTransaction::open('biblioteca'); // open a transaction with database
            $object = new SysRetiradasAcervo($key); // instantiates the Active Record
            
            $usuario = $object->tb_usuario;
            
            if ($object->Tbr_renovado > $usuario->categoria->Tca_reno_qtde)
            {
                throw new Exception('ATENÇÃO: LIMITE DE RENOVAÇÃO ATINGIDO.');
            }
            elseif (date('Y-m-d') > $object->Tbr_devolucao)
            {
                $dt_hoje = new DateTime();
                $dias = $dt_hoje->diff(new DateTime($object->Tbr_devolucao));
                $dias = $dias->format('%a');
                
                $pvmulta = new SysBiblioteca(1);
                
                $valor_multa = $dias * $pvmulta->Bib_multa_dia;
                
                $multa = new SysMultasBaixa();
                $multa->Tmu_idretirada  = $object->Tbr_idcontrole;
                $multa->Tmu_idregistro  = $object->Tbr_idregistro;
                $multa->Tmu_idusuario   = $object->Tbr_idusuario;
                $multa->Tmu_retirada    = $object->Tbr_retirada;
                $multa->Tmu_devolucao   = $object->Tbr_devolucao;
                $multa->Tmu_multa_valor = $valor_multa;
                $multa->Tmu_multa_tipo  = 2;
                $multa->Tmu_multa_paga  = 1;
                $multa->Tmu_multa_opus  = TSession::getValue('login');
                $multa->store();
                
                $dias_renovacao = $usuario->categoria->Tca_reno_dias;
                $object->Tbr_renovado++;
                $object->Tbr_opus_ren = TSession::getValue('login');
                $object->Tbr_opus_mul = TSession::getValue('login');
                $object->Tbr_devolucao = date('Y-m-d', strtotime("+{$dias_renovacao} days"));
                $ddev = date("w", strtotime($object->Tbr_devolucao));
                if ($ddev == 6) {
                    $object->Tbr_devolucao = date('Y-m-d', strtotime("+2 days"));
                }
                if ($ddev == 0) {
                    $object->Tbr_devolucao = date('Y-m-d', strtotime("+1 days"));
                }
                $object->store();
                
                $usuario->Tbu_debito += $valor_multa;
                $usuario->store();
                $valor_multa= number_format($valor_multa, 2, ',', '.');               
                new TMessage('warning', "RENOVADO FORA DO PRAZO: VALOR DA MULTA = R$ <b>{$valor_multa}</b>"); // warning message
            }
            else
            {
                $object->Tbr_renovado++;
                $object->Tbr_opus_ren  = TSession::getValue('login');
                $object->Tbr_devolucao = date('Y-m-d', strtotime("+{$usuario->categoria->Tca_reno_dias} days",strtotime($object->Tbr_devolucao)));
                $ddev = date("w", strtotime($object->Tbr_devolucao));
                if ($ddev == 6) {
                    $object->Tbr_devolucao = date('Y-m-d', strtotime("+2 days"));
                }
                if ($ddev == 0) {
                    $object->Tbr_devolucao = date('Y-m-d', strtotime("+1 days"));
                }
                $object->store();
                new TMessage('info', "RENOVAÇÃO EFETUADA COM SUCESSO"); // success message
            }
            TTransaction::close(); // close the transaction
            $this->onReload( $param ); // reload the listing
            
        }
        catch (Exception $e) // in case of exception
        {
            new TMessage('error', $e->getMessage()); // shows the exception error message
            TTransaction::rollback(); // undo all pending operations
        }
    }
     /**
     * Ask before return
     */
    public function onDevolve($param)
    {
        // define the delete action
        $action = new TAction(array($this, 'Devolve'));
        $action->setParameters($param); // pass the key parameter ahead
        
        // shows a dialog to the user
        new TQuestion(('Confirma DEVOLUÇÃO do Acervo ?'), $action);
    }
    /**
     * Devolve acervo
     */
    public function Devolve($param)
    {
        try
        {
            $key=$param['key'];                            // get the parameter $key
            TTransaction::open('biblioteca');              // open a transaction with database
            $object = new SysRetiradasAcervo($key);        // instantiates the Active Record
            
            $usuario = $object->tb_usuario;
 <b>            
            // Devolução com multa
            if (date('Y-m-d') > $object->Tbr_devolucao) 
            {
                $dt_hoje = new DateTime();
                $dias = $dt_hoje->diff(new DateTime($object->Tbr_devolucao));
                $dias = $dias->format('%a');
                
                $param = new SysBiblioteca(1);
                
                $valor_multa = $dias * $param->Bib_multa_dia;
                
                $multa = new SysMultasBaixa();
                $multa->Tmu_idretirada  = $object->Tbr_idcontrole;
                $multa->Tmu_idregistro  = $object->Tbr_idregistro;
                $multa->Tmu_idusuario   = $object->Tbr_idusuario;
                $multa->Tmu_retirada    = $object->Tbr_retirada;
                $multa->Tmu_devolucao   = $object->Tbr_devolucao;
                $multa->Tmu_devolvido   = date('Y-m-d');
                $multa->Tmu_multa_valor = $valor_multa;
                $multa->Tmu_multa_tipo  = 1;
                $multa->Tmu_multa_paga  = 1;
                $multa->Tmu_multa_opus  = TSession::getValue('login');
                $multa->store();
                
                $object->Tbr_opus_mul = TSession::getValue('login');
                $object->Tbr_opus_dev = TSession::getValue('login');
                $object->Tbr_devolvido = date('Y-m-d');
                $object->store();
                
                $registro = $object->tb_acervo_cons;
                $registro->Tba_idsituacao = 'B';
                $registro->Tba_data_devolucao = date('Y-m-d');
                $registro->store();
                
                $usuario->Tbu_debito += $valor_multa;
                $usuario->Tbu_retiradas -= 1;
                
                if ($usuario->Tbu_retiradas == 0) {
                    $usuario->Tbu_tipo_emprestimo = 1;
                }
                
                $usuario->store();
     
                $valor_multa= number_format($valor_multa, 2, ',', '.');              
                new TMessage('warning', "DEVOLUÇÃO FORA DO PRAZO: VALOR DA MULTA = R$ <b>{$valor_multa}</b>"); // warning message
 
            } </b>
            else
            {
                // Devolução no prazo sem multa
                $usuario->Tbu_retiradas--;
                
                if ($usuario->Tbu_retiradas == 0) {
                    $usuario->Tbu_tipo_emprestimo = 1;
                }
                $usuario->store();
                
                $registro = $object->tb_acervo_cons;
                $registro->Tba_idsituacao = 'B';
                $registro->Tba_data_devolucao = date('Y-m-d');
                $registro->store();
                
                $object->Tbr_opus_dev = TSession::getValue('login');
                $object->Tbr_devolvido = date('Y-m-d');
                $object->store();
                new TMessage('info', "DEVOLUÇÃO EFETUADA COM SUCESSO"); // success message
            }
 
            TTransaction::close();     // close the transaction
            $this->onReload( $param ); // reload the listing
        }
        catch (Exception $e) // in case of exception
        {
            new TMessage('error', $e->getMessage()); // shows the exception error message
            TTransaction::rollback(); // undo all pending operations
        }
    }
    
    /**
     * method show()
     * Shows the page
     */
    public function show()
    {
        // check if the datagrid is already loaded
        if (!$this->loaded AND (!isset($_GET['method']) OR !(in_array($_GET['method'],  array('onReload', 'onSearch')))) )
        {
            if (func_num_args() > 0)
            {
                $this->onReload( func_get_arg(0) );
            }
            else
            {
                $this->onReload();
            }
        }
        parent::show();
    }
}