<?php
/**
 * Copyright 2005-2017 de Solis Soluções Livres Ltda.
 *
 * Este arquivo é parte do programa Gnuteca.
 *
 * O Gnuteca é um software de propriedade da SOLIS, sendo desenvolvido
 * e mantido exclusivamente por esta empresa.
 *
 * A licença de uso está disponível mediante aquisição exclusiva junto à
 * SOLIS. A licença é concedida sem caráter de exclusividade ao licenciado.
 * Os direitos de uso são perpétuos.
 *
 * Embora os códigos fontes sejam fornecidos, o software é de propriedade
 * da SOLIS, não sendo permitido ao adquirente da licença a sua revenda,
 * empréstimo ou cessão (onerosa ou não) à terceiros. Também não é permitido,
 * a qualquer título e tempo, promover no software qualquer tipo de alienação,
 * reprodução, distribuição, divulgação, registro, licenciamento, transferência
 * ou qualquer outro ato que prejudique ou comprometa os direitos de propriedade
 * de software, o nome e a imagem da sua proprietária e do próprio software,
 * além de configurar concorrência à SOLIS.
 *
 * O licenciado, com o acesso ao código fonte do software, terá o direito de
 * promover mudanças no respectivo código. No entanto, nas situações em que ele
 * contar com o suporte oficial prestado pela SOLIS, não poderá promover mudanças
 * no código fonte, sob pena de perda do referido suporte.
 *
 * Para conhecer em detalhes o Termo de Licenciamento do Software Gnuteca
 * leia o arquivo “LICENCA.txt” disponível junto ao código deste software.
 * 
 * 
 * DictionaryContent form
 *
 *
 *
 *
 *
 **/
class FrmDictionaryContent extends GForm
{
	public $MIOLO;
	public $module;
	public $busDictionary;
    public $_dictionaryRelatedContent;
    public $_dictionaryRemissive;
    public $busDictionaryRelatedContent;
    public $busDictionaryRemissive;


    public function __construct()
    {
    	$this->MIOLO  = MIOLO::getInstance();
    	$this->module = MIOLO::getCurrentModule();
    	$this->busDictionary = $this->MIOLO->getBusiness($this->module, 'BusDictionary');
        $this->busDictionaryRelatedContent = $this->MIOLO->getBusiness($this->module, 'BusDictionaryRelatedContent');
        $this->busDictionaryRemissive = $this->MIOLO->getBusiness($this->module, 'BusDictionaryRemissive');

        $this->function = MIOLO::_REQUEST('function');

        if ( ($this->function == 'search') || ($this->function == '') )
        {
            $this->setAllFunctions('DictionaryContent', array('dictionaryId'),array('dictionaryContentId'));
            $this->setSearchFunction('searchDictionaryContentToGrid');
        }
        else
        {
            $busDictionaryContent = $this->MIOLO->getBusiness($this->module, 'BusDictionaryContent');
            $dictionaryContent = $busDictionaryContent->getDictionaryContent(MIOLO::_REQUEST('dictionaryContentId'));
            $dictionaryId = $dictionaryContent->dictionaryId;
            $dictionary = $this->busDictionary->getDictionary($dictionaryId);
        
            if ( MUtil::getBooleanValue($dictionary->allowInsertContent) )
            {
                $this->information(_M("Este dicionário não permite inserção de conteúdos!", $this->module), $this->MIOLO->getActionURL($this->module, MIOLO::getCurrentAction()));
            }
            
            $this->setAllFunctions('DictionaryContent', array('dictionaryId'), 'dictionaryContentId', array('dictionaryId'));
        }

        parent::__construct();

        if ( $this->function == 'insert' && $this->getEvent() == 'tbBtnNew:click' )
        {
            $this->_dictionaryRelatedContent->clearData();
            $this->_dictionaryRemissive->clearData();
            $_SESSION['dicionarioAlterado'] = false;
        }
    }

    public function mainFields()
    {        
    	$tag = MIOLO::_REQUEST('openerRelated');
    	$tag = str_replace('_', '.',substr($tag, -5));
    	$dictionaryId = '';

    	if ( strlen($tag) > 0 )
    	{
	    	$dictionary = $this->busDictionary->checkExistsDictionaryForTag($tag);
	    	$dictionaryId = $dictionary->dictionaryId;
	    	$this->setFocus('dictionaryContent');
    	}
    	
        if ( ( $this->function == 'search' ) || ( $this->function == '' ) )
        {
            $dictionaryContentIdS = new MTextField('dictionaryContentIdS', null, _M('Código', $this->module), FIELD_ID_SIZE);
            $fields[] = $dictionaryContentIdS;
        }

        if ( $this->function == 'update' )
        {
            $dictionaryContentId = new MTextField('dictionaryContentId', null,   _M('Código', $this->module), FIELD_ID_SIZE);
            $fields[] = $dictionaryContentId;
            $dictionaryContentId->setReadOnly(TRUE);
            $validators[] = new MRequiredValidator('dictionaryContentId');
        }

        if ( ( $this->function == 'search' ) || ( $this->function == '' ) )
        {
            $fields[] = new GSelection('dictionaryId', $dictionaryId, _M('Dicionário', $this->module), $this->busDictionary->listDictionary());
        }
        else
        {
            // Não lista dicionários somente leitura.            
            $this->busDictionary->allowInsertContent = DB_TRUE;
            $this->busDictionary->description = null;
            $this->busDictionary->tags = null;
            $fields[] = new GSelection('dictionaryId', $dictionaryId, _M('Dicionário', $this->module), $this->busDictionary->searchDictionary());
        }
        $fields[] = new MTextField('dictionaryContent', null, _M('Conteúdo', $this->module), FIELD_DESCRIPTION_SIZE);

        if ( $this->function == 'update' )
        {
            $fields[] = new MCheckBox('updateMaterialContent', 'updateMaterialContent', _M('Atualizar o conteúdo dos materiais relacionados', $this->module), false );
        }
        
        if ( ( $this->function == 'search' ) || ( $this->function == '' ) )
        {
            $remissiveContentS = new MTextField('remissiveContentS', null, _M('Remissiva', $this->module), FIELD_DESCRIPTION_SIZE);
            $fields[] = $remissiveContentS;
            
            $relatedContentS = new MTextField('relatedContentS', null, _M('Conteúdo relacionado', $this->module), FIELD_DESCRIPTION_SIZE);
            $fields[] = $relatedContentS;
        }

        $fields[] = new MSeparator('<br/>');

        if ( ($this->function == 'insert') || ($this->function == 'update') )
        {
            if  ( ($this->primeiroAcessoAoForm()) && (strlen($tag) == 0) )
            {
                $this->setFocus('dictionaryId');
            }

            $validators[] = new MRequiredValidator('dictionaryContent');
            $validators[] = new MRequiredValidator('dictionaryId');
            
            $remisseFields = array();
            $remissieveValids = array();
            
            $remisseFields[] = new MTextField('remissiveContent', null, _M('Remissiva', $this->module), FIELD_DESCRIPTION_SIZE);
	        $remissieveValids[] = new MRequiredValidator('remissiveContent');
            
            $dictionaryRemissiveId = new MTextField('dictionaryRemissiveId');
            $dictionaryRemissiveId->setVisibility(FALSE);
            $remisseFields[] = $dictionaryRemissiveId;
            
            $dictionaryRemissiveIdAux = new MTextField('dictionaryRemissiveIdAux');
            $dictionaryRemissiveIdAux->setVisibility(FALSE);
            $remisseFields[] = $dictionaryRemissiveIdAux;
            
            $columns = array();
	        $columns[] = new MGridColumn(_M('Remissiva', $this->module), MGrid::ALIGN_LEFT, true, null, true,  'remissiveContent');
	        $columns[] = new MGridColumn(_M('Código da remissiva', $this->module), MGrid::ALIGN_LEFT, true, null, false, 'dictionaryRemissiveId');
	        $columns[] = new MGridColumn(_M('Código da remissiva Auxiliar', $this->module), MGrid::ALIGN_LEFT, true, null, false, 'dictionaryRemissiveIdAux');

            $this->_dictionaryRemissive = new GRepetitiveField('dictionaryRemissive', _M('Remissiva', $this->module), $columns, $remisseFields);
	        $this->_dictionaryRemissive->setValidators($remissieveValids);
            $fields[] = $this->_dictionaryRemissive;

            $flds = array();
            $columns = array();
            $valids = array();
            
	        $flds[] = new MTextField('relatedContent', null, _M('Conteúdo relacionado', $this->module), FIELD_DESCRIPTION_SIZE);
	        $dictionaryRelatedContent = new MTextField('dictionaryRelatedContentId');
            $dictionaryRelatedContent->setVisibility(FALSE);
            $flds[] = $dictionaryRelatedContent;
	        $columns[] = new MGridColumn(_M('Conteúdo relacionado', $this->module),                 MGrid::ALIGN_LEFT, true, null, true,  'relatedContent');
	        $columns[] = new MGridColumn(_M('Código do conteúdo do dicionário relatado', $this->module), MGrid::ALIGN_LEFT, true, null, false, 'dictionaryRelatedContentId');
	        $valids[] = new MRequiredValidator('relatedContent');
	        $this->_dictionaryRelatedContent = new GRepetitiveField('dictionaryRelatedContent', _M('Conteúdo relacionado', $this->module), $columns, $flds);
	        $this->_dictionaryRelatedContent->setValidators($valids);
	        $fields[] = $this->_dictionaryRelatedContent;
            
        }

        $fields[] = new MHiddenField('relatedEdit');
        $this->setFields($fields);
        
        if ($validators)
        {
            $this->setValidators($validators);
        }
    }

    public function tbBtnDelete_click($sender = NULL)
    {
        $dictionaryContentId = MIOLO::_REQUEST('dictionaryContentId');
        if ( strlen($dictionaryContentId) == 0 )
        {
            $dictionaryContentIdArray = array();
            foreach($sender->selectGrdDictionaryContent as $line)
            {
                $dictionaryContentIdArray = explode('=', $line);
            }
            
            $dictionaryContentId = $dictionaryContentIdArray[1];
        }
        
        $busDictionaryContent = $this->MIOLO->getBusiness($this->module, 'BusDictionaryContent');
        $dictionaryContent = $busDictionaryContent->getDictionaryContent($dictionaryContentId);
        $dictionaryId = $dictionaryContent->dictionaryId ? $dictionaryContent->dictionaryId : $sender->dictionaryId;
        $dictionary = $this->busDictionary->getDictionary($dictionaryId);

        if ( !MUtil::getBooleanValue($dictionary->allowInsertContent) )
        {
            $this->information(_M("Este dicionário é somente leitura!", $this->module), $this->MIOLO->getActionURL($this->module, MIOLO::getCurrentAction()));
        }
        else
        {
            parent::tbBtnDelete_click($sender);
        }
    }

    public function tbBtnDelete_confirm($opts)
    {
        $opts = GUtil::decodeJsArgs($opts);
        $opts->event = 'deleteConfirm';
        $optsYes = clone $opts;
        $optsYes->removeFromMaterial = DB_TRUE;

        $optsNo = clone $opts;
        $optsNo->removeFromMaterial = DB_FALSE;
        $this->question( _M("Deseja atualizar os materiais que utilizam este conteúdo?", $this->module) , GUtil::getAjax('deleteConfirm', $optsYes), GUtil::getAjax('deleteConfirm', $optsNo));
    }

    public function deleteConfirm($opts)
    {
        $optsTmp = GUtil::decodeJsArgs($opts);

        if ( $optsTmp->removeFromMaterial == DB_TRUE )
        {
            $_SESSION['deleteMaterialContent'] = true;
        }
        else
        {
            $_SESSION['deleteMaterialContent'] = false;
        }

        return parent::tbBtnDelete_confirm($opts);
    }

    public function tbBtnSave_click($sender = NULL)
    {
        $this->mainFields();
        
        $data = $this->getData();
        $data->dictionaryRelatedContent = $this->_dictionaryRelatedContent->getData();
        $data->dictionaryRemissive = $this->_dictionaryRemissive->getData();
        
        //Tratamento especifico para quando formulario veio da lookup, na Catalogacao
        $errors = $this->gValidator->validate( $data );

        if (MIOLO::_REQUEST('from') == 'lookup' && !$errors)
        {
            $this->business->setData( $data );
            $insert             = call_user_func(array($this->business, $this->insertFunction)); //true/false
            $codigo             = $this->business->dictionaryContentId;
            $dictionaryContent  = $this->business->getDictionaryContent( $codigo );
            $value              = addslashes( $dictionaryContent->dictionaryContent );

            $this->page->onload("
                id = '".MIOLO::_REQUEST('openerRelated')."';
                opener.dojo.byId(id).value = '{$value}';
                self.close();
            ");

            $this->setResponse( null, 'divResponse');
            return;
        }

        $id = MIOLO::_REQUEST('dictionaryContentId');

        $olderContent   = $_SESSION['olderdictionaryContent'];
        $currentContent = MIOLO::_REQUEST('dictionaryContent');
        
        // Obtém dados do dicionário, verifica se possui campo destino de remissiva.
        $dictionaryObject = $this->busDictionary->getDictionary(MIOLO::_REQUEST('dictionaryId'));
        
        if ( (($dictionaryObject->remissiveTag && $_SESSION['dicionarioAlterado'] == true) || $olderContent != $currentContent) && MIOLO::_REQUEST('updateMaterialContent') )
        {           
            $args['olderContent']           = urlencode($olderContent);
            $args['currentContent']         = urlencode($currentContent);
            $args['dictionaryContentId']    = MIOLO::_REQUEST('dictionaryContentId');
            $args['dictionaryId']           = MIOLO::_REQUEST('dictionaryId');
            
            if ( $olderContent != $currentContent )
            {
                $args['updateContent'] = true;
            }
            
            if ($_SESSION['dicionarioAlterado'] == true )
            {
                $args['updateRemissives'] = true;
            }

            $count = $this->business->getUpdateMaterialContentCount( MIOLO::_REQUEST('dictionaryId') , $olderContent);

            $this->question( _M("Deseja atualizar os @1 materiais que utilizam este conteúdo?", $this->module, $count) , GUtil::getAjax('updateMaterialContent', $args), GUtil::getCloseAction(true));
        }
        else
        {
            parent::tbBtnSave_click($sender, $data);
        }
    }

    public function updateMaterialContent()
    {
        // Inicia a transação.
        $this->business->beginTransaction();
        
        // Atualiza obras com o novo conteúdo do dicionário.
        if ( MIOLO::_REQUEST('updateContent') )
        {
            $this->business->updateMaterialContent( MIOLO::_REQUEST('dictionaryId') , urldecode(MIOLO::_REQUEST('olderContent')) , urldecode(MIOLO::_REQUEST('currentContent')));
        }
        
        // Atualiza as remissivas.
        if ( MIOLO::_REQUEST('updateRemissives') )
        {
            $this->mainFields();
            $this->busDictionaryRemissive->updateMaterialContent(MIOLO::_REQUEST('dictionaryId'),  MIOLO::_REQUEST('dictionaryContentId'), urldecode(MIOLO::_REQUEST('currentContent')), $this->_dictionaryRemissive->getData());
        }
        
        $this->saveDictionaryContent();
    }

    public function loadFields()
    {
        $this->business->getDictionaryContent( MIOLO::_REQUEST('dictionaryContentId') );
        $this->setData( $this->business );
        $this->_dictionaryRelatedContent->setData($this->business->dictionaryRelatedContent);
        $this->_dictionaryRemissive->setData($this->business->dictionaryRemissive);
        $_SESSION['olderdictionaryContent'] = $this->dictionaryContent->value;
    }

    public function showRelatedContent()
    {
        $dictionaryContentId = MIOLO::_REQUEST('dictionaryContentId');
        $this->busDictionaryRelatedContent->dictionaryContentId = $dictionaryContentId;
        $search = $this->busDictionaryRelatedContent->searchDictionaryRelatedContent(TRUE);
        
        if ($search)
        {
            //Cria o array com os dados
            $tbData = array();
            
            foreach ($search as $v)
            {
                $tbData[] = array( $v->relatedContent );
            }

            //Cria as colunas
            $tbColumns = array( _M('Conteúdo relacionado', $this->module));

	        $tb = new MTableRaw('', $tbData, $tbColumns);
	        $tb->zebra = TRUE;
        }
        else
        {
            $tb = new MLabel(_M('Nenhum registro encontrado.', $this->module));
        }

        $this->injectContent($tb, true, _M('Conteúdo relacionado', $this->module));
    }


    public function forceAddToTable($args)
    {
        $item = $args->GRepetitiveField;
        $_SESSION['dicionarioAlterado'] = true;
        
        //Verifica se foi uma edicao
        if (MUtil::getBooleanValue($args->relatedEdit))
        {
            $args->dictionaryRelatedContentId = null;
        }
        
        parent::forceAddToTable($args);
        $this->page->onLoad("document.getElementById('relatedEdit').value = 'f'");
    }

    public function editFromTable($args)
    {
        $_SESSION['dicionarioAlterado'] = true;
        
        parent::editFromTable($args);
        $this->page->onLoad("document.getElementById('relatedEdit').value = 't'");
    }
    
    public function removeFromTable( $args )
	{
        $_SESSION['dicionarioAlterado'] = true;
        
		parent::removeFromTable( $args );
	}
    
    //Retorna o modo do formulário busca ou inserção
    public function getFormMode()
    {
        if ( !$this->function || $this->function == 'search' )
        {
            return search;
        }

        return 'manage';
    }

	public function saveDictionaryContent()
	{
        $this->mainFields();

        $data = !is_null($data) ? $data : $this->getData();
        $function = MIOLO::_REQUEST('function');

        if ( !$this->validate($data, $errors) )
        {
            return false;
        }

        // Define os dados.
        $this->business->setData( $data );

        $optsYes    = array( 'event'=>'tbBtnNew_click', 'function' => $function, 'pn_page' => 1 );
        $gotoYes    = $this->MIOLO->getActionURL($this->module, $this->_action, null, $optsYes);
        $optsNo     = array( 'function'=>'search' , 'pn_page' => 1 );
        $optsNo     = array_merge($optsNo, $this->getOptsSave() );

        //faz urlencode de cada atributo para passar via get na mensagem de finalização
        if ( is_array( $optsNo ) )
        {
            foreach ( $optsNo as $line => $opts )
            {
                $optsNo[$line] = urlencode( $opts );
            }
        }

        $gotoNo = $this->MIOLO->getActionURL($this->module, $this->_action, null, $optsNo);

        if ( ( $this->insertFunction || $method ) && ( $function == 'insert' ) )
        {
            $method = is_null($method) ? $this->insertFunction : $method;
          //  $this->business->beginTransaction();
            $ok = call_user_func(array($this->business, $method));
            $key = $this->pKeys[0];

            //caso tenha acontecido a excessão acima, não faz o commit no banco
            $thus->business->commitTransaction();

            $keyValue = $this->business->$key;

            //caso tenha a chave que vem do banco, inclui na listagem
            if ( $keyValue )
            {
                $optsNo[$key.'S'] = $keyValue;
                $gotoNo = $this->MIOLO->getActionURL($this->module, $this->_action, null, $optsNo);
            }

            if($ok)
            {
                //limpa a sessão das repetitivefield
                if ( $this->fields )
                {
                    foreach ( $this->fields as $line => $field )
                    {
                        if ( $field instanceof GRepetitiveField)
                        {
                            GRepetitiveField::clearData($field->name);
                            $_REQUEST[$name] = null; //coloca no request para funcionar com MIOLO::_REQUEST
                        }
                    }
                }

                $this->question( MSG_RECORD_INSERTED , $gotoYes, $gotoNo);
                $_SESSION['dicionarioAlterado'] = false;

                return true;
            }
        }
        elseif ( ($this->updateFunction || $method ) && ($function == 'update') )
        {
            $method = is_null($method) ? $this->updateFunction : $method;
          //  $this->business->beginTransaction();
            $ok  = call_user_func(array($this->business, $method));
            $this->business->commitTransaction();

            if($ok)
            {
                //limpa a sessão das repetitivefield
                if ( $this->fields )
                {
                    foreach ( $this->fields as $line => $field )
                    {
                        if ( $field instanceof GRepetitiveField)
                        {
                           // GRepetitiveField::clearData($field->name);
                            $_REQUEST[$name]   = null; //coloca no request para funcionar com MIOLO::_REQUEST
                        }
                    }
                }

                $this->information( MSG_RECORD_UPDATED, $gotoNo);
                $_SESSION['dicionarioAlterado'] = false; 
                
                return true;
            }
        }

        $errorMsg = MSG_RECORD_ERROR;

        if (method_exists($business, 'getErrors') && ($errors = $business->getErrors()))
        {
            $errorMsg = implode('<br>', $errors);
        }

        $this->error( $errorMsg, 'javascript:'. GUtil::getCloseAction(), _M('Erro',$this->module) );

        return false;
	}
    
}
?>
