<?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.
 * 
 * 
 * Gnuteca Task
 *
 *
 *
 *
 *
 **/
abstract class GTask
{
    protected   $MIOLO, $module;
    protected   $myTask;
    protected   $busScheduleTaskLog;
    protected   $parameters;
    private     $startTime;

    const STARTING_LOG_MSG  = "Iniciando agendamento de tarefa";
    const SUCCESS_LOG_MSG   = "Sucesso no agendamento da tarefa";
    const UNSUCCESS_LOG_MSG = "Falha no agendamento da tarefa";

    /**
     *
     * @param OBJECT $MIOLO
     */
    function __construct($MIOLO, $myTask)
    {
        $this->MIOLO        = $MIOLO;
        $this->myTask       = $myTask;
        $this->module       = $this->MIOLO->getCurrentModule();

        $this->busScheduleTaskLog = $this->MIOLO->getBusiness($this->module, 'BusScheduleTaskLog');
    }

    /**
     * retorna a id da tarefa que pode ser setada apenas no construct
     *
     * @return integer
     */
    protected function getMyTaskId()
    {
    	if ( $this->myTask->ScheduleTaskId )
    	{
    		$taskId = $this->myTask->ScheduleTaskId;
    	}
    	else
    	{
    		$taskId = $this->myTask->scheduleTaskId;
    	} 
        
        return $taskId;
    }

    /**
     * Registra um conteudo no log
     *
     * @param string $msg
     */
    protected function registerLog($msg, $status)
    {
        $this->busScheduleTaskLog->scheduleTaskId = $this->getMyTaskId();
        $this->busScheduleTaskLog->log = $msg;
        $this->busScheduleTaskLog->status = $status;
        
        $this->busScheduleTaskLog->insertScheduleTaskLog();
    }

    /**
     * Registra log de inicialização
     */
    public function startLog()
    {
        $this->registerLog(self::STARTING_LOG_MSG, 'START');
    }

    /**
     * Registra log de finalização
     *
     * @param boolean $ok
     */
    public function concludeLog($ok = true, $extraMessage = '' )
    {
        if ($ok)
        {
            $this->registerLog(self::SUCCESS_LOG_MSG, 'END_SUCESS');
        }
        else
        {
            $this->registerLog(self::UNSUCCESS_LOG_MSG . '.  Erro: ' . $extraMessage, 'END_ERROR') ;
        }
    }

    /**
     * Set o tempo que iniciou a execução do script principal.
     *
     * @param unknown_type $startTime
     */
    public function setStartTime($startTime=NULL)
    {
        $this->startTime = $startTime;
    }

    /**
     * Este método verifica se é preciso executar o script
     *
     * @return boolean
     */
    public function needExecute()
    {
        $time = str_replace(array("Y", "m", "d", "H", "w"),
                            array($this->startTime->Y, $this->startTime->m, $this->startTime->d, $this->startTime->H, $this->startTime->w),
                            $this->myTask->ScheduleCycleValueType);
        
        $find = false;  
        // Check para ver se esta no dia e hora correta para executar                  
        if ( $cycles = explode(';', $this->myTask->ScheduleTaskCycleValue) )
        {
        	foreach( $cycles as $cycle )
        	{
        	   	if ( $time == $cycle )
        	   	{
        	   		$find = true;
        	   		break;
        	   	}
        	}
        }
        elseif($time == $this->myTask->ScheduleTaskCycleValue)
        {
                $find = true;
        }
        
        if (!$find)
        {
        	return false;
        }

        // REGISTRA LOG DE INICIO DA TAREFA
        $this->startLog();
        return true;
    }

    /**
     * Este metodo verifica se é preciso ser executado
     *
     * @return booelan
     */
    public function execute()
    {
        return $this->needExecute();
    }

    /**
     * Seta os parametros para a classe
     *
     * @param string $parameters
     */
    public function setParameters($parameters)
    {
        $this->parameters = explode('|', $parameters);
    }
    
    /**
     * Verifica se está rodando de dentro da GCron
     * 
     * @global array $_SERVER
     * @return boolean
     */
    public function isRunningFromGCron()
    {
        global $_SERVER;
        
        if ( !$_SERVER['argv'] )
        {
            throw new Exception( _M('Tarefa somente pode ser executada pela GCron pois precisa de acesso administrativo.','gnuteca3') );
        }
        
        return true;
    }
    
    /* Executar tarefa utilizando parâmetro
     * Foi implementada para utilizarmos na Univates
     * Será um método o mais genérico possível, pasivo para novas utilizações
     *
     * Criada em 06/08/2014
     * Por: Tcharles Silva
     */
    public function executeTaskId($taskId, $parameter)
    {
        $MIOLO = MIOLO::getInstance();
        $module = 'gnuteca3';
        
        //Instancia a busTask
        $busTask = $MIOLO->getBusiness($module, 'BusTask'); //instancia o business da tarefa
        $busScheduleTask = $MIOLO->getBusiness($module, 'BusScheduleTask'); //instancia o business da tarefa
        
        //pega o id da tarefa passada pelo parâmetro
        $scheduleTaskId = $taskId; 
        
        //Pega o objeto tarefa
        $scheduleTask = $busScheduleTask->getScheduleTask($scheduleTaskId); //pega a tarefa agendada
        
        //Obtem a tarefa
        $task = $busTask->getTask($scheduleTask->taskId);
        
        /* ?? LOCAL FILE ?? */
        $localFile = $MIOLO->getConf('home.modules') . '/' . $module . '/misc/scripts'; //pega o path dos scripts
        
        $busScheduleTask->setScriptPath($localFile); //seta o path dos scripts
        
        $task = (object) array_merge((array) $task, (array) $scheduleTask); //mescla os dados da tarefa e tarefa agendada
        
        $obj = $busScheduleTask->instanceObjectTask($task); //intancia objeto da tarefa
        
        if($parameter)
        {
            $obj->setParameters($parameter); //seta os parâmetro
        }
        
        $obj->setStartTime(); //registra a data/hora de início
        $obj->startLog(); //grava log de start
        
        try
        {
            $ok = $obj->execute();
            $obj->concludeLog(true, 'SUCESSO!' );
            return true;
        }
        catch ( Exception $e )
        {
            $obj->concludeLog(false, $e->getMessage() ); 
            return false;
        }
    }
}
?>