<?php
/**
 * <--- Copyright 2005-2013 de Solis - Cooperativa de Soluções Livres Ltda. e
 * Univates - Centro Universitário.
 *
 * Este arquivo é parte do programa Gnuteca.
 *
 * O Gnuteca é um software livre; você pode redistribuí-lo e/ou modificá-lo
 * dentro dos termos da Licença Pública Geral GNU como publicada pela Fundação
 * do Software Livre (FSF); na versão 2 da Licença.
 *
 * Este programa é distribuído na esperança que possa ser útil, mas SEM
 * NENHUMA GARANTIA; sem uma garantia implícita de ADEQUAÇÃO a qualquer MERCADO
 * ou APLICAÇÃO EM PARTICULAR. Veja a Licença Pública Geral GNU/GPL em
 * português para maiores detalhes.
 *
 * Você deve ter recebido uma cópia da Licença Pública Geral GNU, sob o título
 * "LICENCA.txt", junto com este programa, se não, acesse o Portal do Software
 * Público Brasileiro no endereço www.softwarepublico.gov.br ou escreva para a
 * Fundação do Software Livre (FSF) Inc., 51 Franklin St, Fifth Floor, Boston,
 * MA 02110-1301, USA --->
 *
 * Classe WebService para GnutecaAutomação
 *
 * @author Tcharles Silva [tcharles@solis.coop.br]
 *
 * @version $Id$
 *
 * \b Maintainers: \n
 * Tcharles Silva [tcharles@solis.coop.br]
 * 
 * 
 *
 * @since
 * Class created on 04/11/2013
 * 
 **/

include("GnutecaWebServices.class.php");
$MIOLO->getClass('gnuteca3', 'GSession');
$MIOLO->getClass('gnuteca3', 'GSipCirculation');

class gnuteca3WebServicesAutomacao extends GWebServices 
{
    public $busSipEquipament;
    public $busSipEquipamentStatusHistory;
    public $busSessionOperation;
    public $busSession;
    public $busOperationLoanSip;
    public $busAuthenticate;
    public $busPerson;
    
    public $busOperationLoan;
    public $busOperationRenew;
    
    public $busReserve;
    public $busReserveComposition;
    public $busLoan;
    public $busFine;
    public $busPolicy;
    public $busBond;
    public $busRight;
    public $busPenalty;
    
    
    public function __construct() {
        parent::__construct();
        
        $MIOLO = MIOLO::getInstance();
        $module = MIOLO::getCurrentModule();
        
        //Instancia os atributos com o objeto Bus$Parametro respectivamente
        $this->busSipEquipament = $MIOLO->getBusiness($module, 'BusSipEquipament');
        $this->busSipEquipamentStatusHistory = $MIOLO->getBusiness($module, 'BusSipEquipamentStatusHistory');
        $this->busSessionOperation = $MIOLO->getBusiness($module, 'BusSessionOperation');
        $this->busSession = $MIOLO->getBusiness($module, 'BusSession');
        $this->busOperationLoan = $MIOLO->getBusiness($module, 'BusOperationLoan');
        $this->busOperationLoanSip = $MIOLO->getBusiness($module, 'BusOperationLoanSip');
        $this->busOperationRenewSip = $MIOLO->getBusiness($module, 'BusOperationRenewSip');
        $this->busAuthenticate = $MIOLO->getBusiness($module, 'BusAuthenticate');
        $this->busPerson = $MIOLO->getBusiness($module, 'BusPerson');
        $this->busLoan = $MIOLO->getBusiness($module, 'BusLoan');
        $this->busFine = $MIOLO->getBusiness($module, 'BusFine');
        $this->busReserve = $MIOLO->getBusiness($module, 'BusReserve');
        $this->busReserveComposition = $MIOLO->getBusiness($module, 'BusReserveComposition');
        $this->busPolicy = $MIOLO->getBusiness($module, 'BusPolicy');
        $this->busBond = $MIOLO->getBusiness($module, 'BusBond');
        $this->busRight = $MIOLO->getBusiness($module, 'BusRight');
        $this->busPenalty = $MIOLO->getBusiness($module, 'BusPenalty');
    }


    /*
     * Esqueleto do LOGIN, retorna booleano caso dados sejam válidos
     * Parametros:
     * 
     * String termID :: id do terminal
     * String pwd :: senha do terminal
     * String location :: localização, campo opcional
     * 
     * Descrição:
     *      Utiliza o método authenticate da BusSipEquipament para se authentificar
     *      Retorno: booleano se conseguiu authentificar
     * 
     * Criado por: Tcharles Silva
     * Em: 21/11/2013
     * Ultima Atualização por: 
     * Em: 
     * Motivo: 
     */
    public function login($termID, $pwd, $location = null) 
    {
        MUtil::flog("---Entrando no método de Login-----");
        
        $ok = 'F';
        $startTime = microtime(true);
        
        $retorno = $this->busSipEquipament->authenticate($termID, $pwd);
        
        if($retorno)
        {
            $ok = 'Y';
        }
        
        $endTime = microtime(true);
        $time = $endTime - $startTime;
        MUtil::flog("Operação realizada em : " . $time);
        return $ok;
    }
    
    
    /*
     * Esqueleto do STATUS, retorna uma String
     * Parametros:
     * 
     * String termID :: id do terminal
     * Integer status :: Pode ser: [0]: OK, [1]: SEM PAPEL, [2]: DESLIGANDO
     * Integer maxPtrWidth :: Tamanho de largura? ----> Ainda não implementado <<----
     * String protocol :: Opcional, não utilizamos
     * 
     * Descrição: WebService de STATUS irá retornar os dados do equipamento
     * Também irá gravar um registro do equipamento que o acessou, com o status atual do mesmo.
     * Registro pode ser visto na tabela gtcSipEquipamentLog
     * 
     * Criado por: Tcharles Silva
     * Em: 21/11/2013
     * Ultima Atualização por: 
     * Em: 
     * Motivo:
     */
    public function status($termID, $status, $maxPtrWidth, $protocol) 
    {
        MUtil::flog("---Entrando no método de Status-----");
        
        $startTime = microtime(true);
        /* OBS:
         * Ainda não foi implementado a utilização do $maxPtrWidth.
         * Futuramente deverá ser implementado.
         */
        
        //Chama o mpetodo checkStatus para verificar o Status
        $retorno = $this->busSipEquipament->checkStatus($termID);
        
        
        //Verifica se esta em alguma biblioteca, caso nulo, não encontrou o $termID
        if($retorno['libraryName'])
        {
            //Seta os dados para inserir
            $this->busSipEquipamentStatusHistory->sipEquipamentId = $termID;
            $this->busSipEquipamentStatusHistory->status = $status;
            $this->busSipEquipamentStatusHistory->insertSipEquipamentStatusHistory();
            
            //Pepara o retorno na variável $backInfo, usando o delimitador SIP_DELIMITER
            $backInfo = implode(SIP_DELIMITER, $retorno);
            
        }
        else
        {
            //Checagem para evitar campos em branco
            if(empty($retorno['timeoutPeriod']))
            {
                $retorno['timeoutPeriod'] = 'null';
            }
            if(empty($retorno['retriesAllowed']))
            {
                $retorno['retriesAllowed'] = 'null';
            }
            if(empty($retorno['institutionId']))
            {
                $retorno['institutionId'] = 'null';
            }
            if(empty($retorno['libraryName']))
            {
                $retorno['libraryName'] = 'null';
            }
            if(empty($retorno['terminalLocation']))
            {
                $retorno['terminalLocation'] = 'null';
            }
            if(empty($retorno['printMsg']))
            {
                $retorno['printMsg'] = 'null';
            }
            
            $backInfo = implode(SIP_DELIMITER, $retorno);
        }
        $endTime = microtime(true);
        $time = $endTime - $startTime;
        
        MUtil::flog("Operação realizada em : " . $time);
        
        MUtil::flog($backInfo);
        return $backInfo;
    }
    
    
    /*
     * Esqueleto endPatronSession, retorna uma String
     * Parametros:
     * 
     * String dateTime ::
     * String instID ::
     * String patronID ::
     * String termID ::
     * String termPwd ::
     * String patronPwd ::
     * 
     * Descrição:
     *      
     * 
     * Criado por: 
     * Em: 
     * Ultima Atualização por: 
     * Em: 
     * Motivo: 
     */
    public function endPatronSession($dateTime, $instID, $patronID, $termID, $termPwd, $patronPwd)
    {   
        MUtil::flog("------ Entrando no endPatronSession---------");
        $startTime = microtime(true);
        
        //Arrays onde ficarão os IDs de empréstimo, devolução e renovação de cada sessão
        $loanIds = Array();
        $returnIds = Array();
        $renewIds = Array();
        
        $loanIds2 = Array();
        $returnIds2 = Array();
        $renewIds2 = Array();
        
        $salva = Gsession::getOpenSession($termID);        
        
        if($salva)
        {
            $this->busSessionOperation->sessionId = $salva->sessionId;
            $this->busSessionOperation->isClosed = DB_FALSE;
            $save = $this->busSessionOperation->searchSessionOperation(TRUE);
            
            MUtil::flog($save);
        
            foreach ($save as $op)
            {
                $loanIds2[] = $op->loanId;
                $returnIds2[] = $op->returnRegisterId;
                $renewIds2[] = $op->renewId;

                if($op->operation == 1)  //Verifica se foi Empréstimo
                {
                    $loanIds[] = $op->loanId;
                    MUtil::flog("Esta adicionando " . $op->loanId);
                
                }
                if($op->operation == 2) //Verifica se foi Devolução
                { 
                    $returnIds[] = $op->returnRegisterId;
                    MUtil::flog("Esta adicionando " . $op->returnRegisterId);
                
                }
                if($op->operation == 3) //Verifica se é Renovação
                {
                    $renewIds[] = $op->renewId;
                    MUtil::flog("Esta adicionando " . $op->renewId);
                }
            }
        }
        
        /*
         * Os numeros dos LoanIds, returnIds e renewIds estão salvos abaixo.
         * 
         * Em cima deles que serão gerados os recibos...
         * 
         * Necessário implementar os recibos.
         */
        
        MUtil::flog("Loans : " . implode('-', $loanIds));
        MUtil::flog("Return : " . implode('-', $returnIds));
        MUtil::flog("Renew : " . implode('-', $renewIds));        
        
        $var = GSession::closeSession($termID);
        $data = GDate::getYYYYMMDDHHMMSS($dateTime);
        
        if($var)
        {
            $retorno['endSession'] = 'Y';
            $msg = "Beleza, finalizou sessão.";
            
            //Implementar o print
        }else
        {
            $retorno['endSession'] = 'N';
            $msg = "Não foi possível finalizar a sessão.";
            
            //Implementar o print
        }
        
        if(empty($print))
        {
            $print = 'null';
        }
        
        $retorno['dateTime'] = $data;
        $retorno['instID'] = $instID;
        $retorno['screenMsg'] = $msg;
        $retorno['printMsg'] = $print;
        
        $backInfo = implode(SIP_DELIMITER, $retorno);
        
        $endTime = microtime(true);
        $time = $endTime - $startTime;
        MUtil::flog("Operação realizada em : " . $time);
        
        MUtil::flog($backInfo);
        return $backInfo;
    }

    
    
    /*
     * Esqueleto CHECKOUT ( Empréstimo ), retorna uma String
     * Parametros:
     * 
     * Boolean renewalPolicy, 
     * Boolean noBlock,
     * String dateTime, 
     * String nbDueDate, 
     * String instID, 
     * String patronID, 
     * String itemID,
     * String termID,
     * String termPwd,
     * String itemProp, 
     * String patronPwd,  
     * Boolean cancel
     * 
     * Descrição:
     *      Método que irá realizar o empréstimo.
     * 
     * Criado por: Tcharles Silva
     * Em: 27/11/2013
     * Ultima Atualização por: 
     * Em: 
     * Motivo: 
     */
    public function checkout($renewalPolicy, $noBlock, $dateTime, $nbDueDate, $instID, $patronID, 
                              $itemID, $termID, $termPwd, $itemProp, $patronPwd, $cancel) 
    {
        MUtil::flog("----- Entrando no checkOut-----");
        $startTime = microtime(true);
        
        //Faz renovacao
        $fazRen = $renewalPolicy;
        
        //Define padrão DefaultSip de empréstimo
        $loanTypeId = ID_LOANTYPE_DEFAULTSIPEQUIPAMENT;
        
        //Caso seja marcado como offline, define o modo offline
        if($nbDueDate){
            $loanTypeId = ID_LOANTYPE_OFFLINE;
        }

        /* PADRÕES DE EMPRÉSTIMOS
           Utilizado em: $padraoLoan 
             1 | Empréstimo
             2 | Devolução
             3 | Renovação
        */
        $padraoLoan = '1';
        $retorno = GSipCirculation::doLoan($padraoLoan, $termID, $patronID, $itemID, $loanTypeId, NULL, $fazRen);
        
        //MUtil::flog("Conteudo do retorno");
        //MUtil::flog($retorno);
        //MUtil::flog($retorno[ok]);
        MUtil::flog($retorno);
        
        if(empty($itemProp))
        {
            $itemProp = 'null';
        }
        
        MUtil::flog("Msg");
        MUtil::flog($retorno[screenMsg]);
        
        if($retorno[ok] == 'Y')
        {
            //Decorrer do código aqui.... Caso tenha concluido a operação
            $ret["ok"] = 'Y';
            $ret["renewalOk"] = $retorno[renewalOk];
            $ret["desensitize"] = "Y";
            $ret["dateTime"] = $retorno[dateTime];
            $ret["instID"] = $retorno[instID];
            $ret["patronID"] = $retorno[patronID];
            $ret["itemID"] = $retorno[itemID];
            $ret["titleID"] = $retorno[titleID];
            $ret["dueDate"] = $retorno[dueDate];
            $ret["securityInhibit"] = 'FALSE';
            $ret["itemProp"] = $itemProp;

            if(is_null($retorno[screenMsg]))
            {
                if($retorno[renewalOk] == 'N')
                {
                    $ret["screenMsg"] = "Sucesso! Empréstimo concluído.";
                }
                else
                {
                    $ret["screenMsg"] = "Sucesso! Renovação concluída.";
                }
            }else
            {
                $ret['screenMsg'] = $retorno[screenMsg];
            }
            
            $ret["printMsg"] = "null";
        }
        else //CASO OCORRA A FALHA
        {   
            $ret["ok"] = 'N';
            $ret["renewalOk"] = "N";
            $ret["desensitize"] = "N";
            
            //Colocar a data no formato abaixo
            $v4 = GDate::getYYYYMMDDHHMMSS($dateTime);
            
            $ret["dateTime"] = $v4;
            $ret["instID"] = $instID;
            $ret["patronID"] = $patronID;
            $ret["itemID"] = $itemID;
            $ret["titleID"] = $retorno[titleID];
            $ret["dueDate"] = $v4;
            $ret["securityInhibit"] = 'FALSE';
            $ret["itemProp"] = $itemProp;
            
            if(is_null($retorno[screenMsg]))
            {
                if($retorno[renewalOk] == 'N')
                {
                    $ret["screenMsg"] = "Falhamos. Problema no empréstimo. Consulte informações no balcão de atendimento.";
                }
                else
                {
                    $ret["screenMsg"] = "Falhamos. Problema na renovação. Consulte informações no balcão de atendimento.";
                }
            }else
            {
                $ret['screenMsg'] = $retorno[screenMsg];
            }
            
            $ret["printMsg"] = "null";
        }
        
        //Monta a string de retorno com as informações        
        $backInfo = implode(SIP_DELIMITER, $ret);
        //MUtil::flog($backInfo);
        
        $endTime = microtime(true);
        $time = $endTime - $startTime;
        MUtil::flog("Operação realizada em : " . $time);
        
        MUtil::flog($backInfo);
        MUtil::flog($retorno[screenMsg]);
        return $backInfo;
    }

    
    
    /*
     * Esqueleto CHECKIN, retorna uma String
     * Parametros:
     * 
     * Boolean noBlock,
     * String dateTime, 
     * String returnDate, 
     * String currentLocation, 
     * String instID, 
     * String itemID, 
     * String termID, 
     * String termPwd,
     * String itemProp, 
     * Boolean cancel
     * 
     * Descrição:
     *      Método que realiza a devolução.
     *      
     * 
     * Criado por: Tcharles Silva
     * Em: 04/12/2013
     * Ultima Atualização por:  Tcharles Silva
     * Em: 04/12/2013
     * Motivo: 
     *      Correções.
     */
    public function checkin($noBlock, $dateTime, $returnDate, $currentLocation, $instID, 
                             $itemID, $termID, $termPwd, $itemProp, $cancel)
    {
        MUtil::flog("------ ENTRANDO NO CHECKIN -------");
        $startTime = microtime(true);
        
        //Chama metodo doReturn com o sipId, e o ItemNumber do livro.
        $retorno = GSipCirculation::doReturn($termID, $itemID);
        
        //MUtil::flog($retorno);
        
        if(empty($itemProp))
        {
            $itemProp = 'null';
        }

        if($retorno[ok] == '1')
        {
            $ret['ok'] = 'Y';
            $ret['resensitize'] = $retorno[resensitize];
            $ret['alert'] = $retorno[alert];
            $ret['dateTime'] = $retorno[dateTime];
            $ret['instID'] = $retorno[instID];
            $ret['itemID'] = $retorno[itemID];
            $ret['permanentLoc'] = '0';
            $ret['titleID'] = $retorno[titleID];
            $ret['patronID'] = $retorno[patronID];
            $ret['itemProp'] = $itemProp;

            if(is_null($retorno[screenMsg])){
                $ret['screenMsg'] = 'Sucesso! Exemplar devolvido: '. $itemID;
            }else{
                $msg = implode('\n', $retorno[screenMsg]);
                $ret['screenMsg'] = $msg;
            }
            
            $ret['printMsg'] = 'null';
        }
        else //CASO OCORRA A FALHA
        {
            $ret['ok'] = 'N';
            $ret['resensitize'] = 'N';
            $ret['alert'] = 'Y';
            $ret['dateTime'] = GDate::getYYYYMMDDHHMMSS($dateTime);
            $ret['instID'] = $instID;
            $ret['itemID'] = $itemID;
            
            $ret['permanentLoc'] = '0';
            $ret['titleID'] = 'null';
            $ret['patronID'] = 'null';
            
            $ret['itemProp'] = $itemProp;

            if(is_null($retorno[screenMsg])){
                $ret['screenMsg'] = 'Desculpe, não consegui fazer a devolução do exemplar: '. $itemID . '. Consulte informações no balcão de atendimento.';
            }else{
                $msg = implode('\n', $retorno[screenMsg]);
                $ret['screenMsg'] = $msg;
            }
            
            $ret['printMsg'] = 'null';
        }
        
        //Monta a string de retorno com as informações        
        $backInfo = implode(SIP_DELIMITER, $ret);
        //MUtil::flog($backInfo);
        
        
        $endTime = microtime(true);
        $time = $endTime - $startTime;
        MUtil::flog("Operação realizada em : " . $time);
        
        MUtil::flog($backInfo);
        MUtil::flog($retorno[screenMsg]);
        return $backInfo;

    }

    
    
    /*
     * Esqueleto itemInformation, retorna uma String
     * Parametros:
     * 
     * String dateTime, 
     * String instID, 
     * String itemID,
     * String termID, 
     * String termPwd
     * 
     * Descrição:
     *      
     * 
     * Criado por: 
     * Em: 
     * Ultima Atualização por: 
     * Em: 
     * Motivo: 
     */
    public function itemInformation($dateTime, $instID, $itemID, $termID, $termPwd) 
    {
        return "Ainda não implementado";
    }

    
    
    /*
     * Esqueleton renew, retorna uma String
     * Parametros:
     * 
     * Boolean thdAllowed, 
     * Boolean noBlock, 
     * String dateTime, 
     * String nbDueDate, 
     * String instID, 
     * String patronID, 
     * String patronPwd, 
     * String itemID, 
     * String titleID, 
     * String termID, 
     * String termPwd, 
     * String itemProp
     * 
     * Descrição:
     *      Método que realiza a renovação.
     * 
     * Criado por: Tcharles Silva
     * Em: 02/12/2013
     * Ultima Atualização por: 
     * Em: 
     * Motivo: 
     */
    public function renew( $thdAllowed, $noBlock, $dateTime, $nbDueDate, $instID, $patronID,
                          $patronPwd, $itemID, $titleID, $termID, $termPwd, $itemProp ) 
    {
        
        MUtil::flog("------ Operação RENEW -------");
        $startTime = microtime(true);
        
        /* - Método doLoan que realiza empréstimo/renovação --
        GSipCirculation::doLoan($padraoLoan, $termId, $personId, $itemNumber, $loanTypeId )
         - padraoLoan = '1'
         - termId = ""
         - personId = ""
         - itemNumber = ""
         - loanTypeId = "4"
         */
        $retorno = GSipCirculation::doLoan('1', $termID, $patronID, $itemID, '4');

        
        //MUtil::flog("Conteudo do retorno");
        //MUtil::flog($retorno);
        //MUtil::flog($retorno[ok]);
        
        MUtil::flog($retorno[screenMsg]);
        
        if($retorno[ok] == 'Y')
        {
            //Decorrer do código aqui.... Caso tenha concluido a operação
            $ret["ok"] = 'Y';
            $ret["renewalOk"] = $retorno[renewalOk];
            $ret["desensitize"] = "Y";
            $ret["dateTime"] = $retorno[dateTime];
            $ret["instID"] = $retorno[instID];
            $ret["patronID"] = $retorno[patronID];
            $ret["itemID"] = $retorno[itemID];
            $ret["titleID"] = $retorno[titleID];
            $ret["dueDate"] = $retorno[dueDate];
            $ret["securityInhibit"] = "N";
            
            if(empty($itemProp))
            {
                $itemProp = 'null';
            }
            $ret["itemProp"] = $itemProp;

            if(is_null($retorno[screenMsg]))
            {
                if($retorno[renewalOk] == 'Y')
                {
                    $ret["screenMsg"] = "Sucesso! Renovação do item " . $itemID . " concluída.";
                }
                else
                {
                    $ret["screenMsg"] = "Sucesso! Empréstimo concluído.";
                }
            }else
            {
                $ret['screenMsg'] = $retorno[screenMsg];
            }
            
            $ret["printMsg"] = "null";
        }
        else //CASO OCORRA A FALHA
        {
            $ret["ok"] = 'N';
            $ret["renewalOk"] = "N";
            $ret["desensitize"] = "N";
            //Colocar a data no formato abaixo
            $v4 = GDate::getYYYYMMDDHHMMSS($dateTime);
            if(empty($v4))
            {
                $v4 = 'null';
            }
            $ret["dateTime"] = $v4;
            
            if(empty($instID))
            {
                $instID = 'null';
            }
            $ret["instID"] = $instID;
            
            if(empty($patronID))
            {
                $patronID = 'null';
            }
            $ret["patronID"] = $patronID;
            
            if(empty($itemID))
            {
                $itemID = 'null';
            }
            $ret["itemID"] = $itemID;
            
            if(empty($retorno[titleID]))
            {
                $retorno[titleID] = 'null';
            }
            $ret["titleID"] = $retorno[titleID];
            
            if(empty($retorno[dueDate]))
            {
                $retorno[dueDate] = 'null';
            }
            $ret["dueDate"] = $retorno[dueDate];
            $ret["securityInhibit"] = "N";
            
            if(empty($itemProp))
            {
                $itemProp = 'null';
            }
            $ret["itemProp"] = $itemProp;

            if(empty($retorno[screenMsg]))
            {
                $retorno[screenMsg] = 'Desculpe, mas não concluí a renovação. Consulte mais informações no balcão de atendimento.';
            }
            $ret['screenMsg'] = $retorno[screenMsg];
            
            $ret["printMsg"] = "null";
        }
        
        //Monta a string de retorno com as informações        
        $backInfo = implode(SIP_DELIMITER, $ret);
        //MUtil::flog($backInfo);
        
        $endTime = microtime(true);
        $time = $endTime - $startTime;
        MUtil::flog("Operação realizada em : " . $time);
        
        MUtil::flog($backInfo);
        MUtil::flog($retorno[screenMsg]);
        return $backInfo;
    }

    
    
    /*
     * Esqueleto de RENEWALL, retorna uma String
     * Parametros:
     * 
     * String dateTime, 
     * String instID, 
     * String patronID, 
     * String patronPwd, 
     * String termID, 
     * String termPwd
     * 
     * Descrição:
     *      
     * 
     * Criado por: 
     * Em: 
     * Ultima Atualização por: 
     * Em: 
     * Motivo: 
     */
    public function renewAll($dateTime, $instID, $patronID, $patronPwd, $termID, $termPwd) 
    { 
        MUtil::flog("----- Operação RENEWALL ------");
        $startTime = microtime(true);
        
        //Formata a data
        $data = GDate::getYYYYMMDDHHMMSS($dateTime);
        
        $this->busLoan->personId = $patronID;
        $this->busLoan->orderByLibraryUnit = TRUE;
        $var = $this->busLoan->getLoansOpen();
        
        //Mensagens de screen
        $sMsg = array();
        
        //Contadores
        $renewalCount = 0;
        $unRenewalCount = 0;
        $numOp = 0;
        
        $renDone = array();
        $renNotDone = array();
        
        ////////////////////////////////////////////////////
        //Recebe informações do equipamento
        $dadosSip = $this->busSipEquipament->getSipEquipament($termID);

        //Setar libraryUnitId e Setar Location
        $this->busOperationLoanSip->setLibraryUnit($dadosSip->libraryUnitId);
        $this->busOperationLoanSip->setLocation($dadosSip->locationformaterialmovementid);
        
        //Setando pessoa para otimizar a renovação de todos os itens
        $pessoa = $this->busOperationLoanSip->setPerson($patronID, $dadosSip->libraryUnitId, $dadosSip->locationformaterialmovementid);
        
        ///////////////////////////////////////////////

        foreach($var as $loan)
        {
            MUtil::flog("--------------------------------------------");
            MUtil::flog("Numero da operação: " . $numOp);
            
            $emp[$numOp] = GSipCirculation::doLoan('1', $termID, $patronID, $loan->itemNumber, '4', $pessoa);
            
            
            if($emp[$numOp][ok] == 'Y'){
                
                $renewalCount++;
                $renDone[] = $loan->itemNumber;
                
                if(!$emp[$numOp][screenMsg]){
                    $sMsg[] = "Exemplar " . $loan->itemNumber . " [Renovado]";
                    MUtil::flog("Exemplar " . $loan->itemNumber . " [Renovado]");
                }
                else{
                    $sMsg[] = $emp[$numOp][screenMsg];
                    MUtil::flog($emp[$numOp][screenMsg]);
                }
            }
            else
            {
                if(!$emp[$numOp][screenMsg]){
                    $sMsg[] = "Exemplar " . $loan->itemNumber . " [Falha]";
                    MUtil::flog("Exemplar " . $loan->itemNumber . " [Falha]");
                }
                else{
                    $sMsg[] = $emp[$numOp][screenMsg];
                    MUtil::flog($emp[$numOp][screenMsg]);
                }
                
                $unRenewalCount++;
                $renNotDone[] = $loan->itemNumber;
            }
            $numOp++;
        }
        
        //Verifica se todas as operações foram renovadas
        if($numOp == $renewalCount){
            $retorno['ok'] = 'Y';
        }else{
            $retorno['ok'] = 'N';
        }

        $retorno['renewalCount'] = $renewalCount;
        $retorno['unRenewalCount'] = $unRenewalCount;
        $retorno['dateTime'] = $data;
        $retorno['instID'] = $instID;
        
        //Verifica se foi feita alguma renovação
        if(count($renDone) < 1)
        {
            $retorno['renewedItens'] = 'null';
        }
        else
        {
            $retorno['renewedItens'] = implode(',', $renDone);
        }
        
        //Verifica se NAO foi feita renovação
        if(count($renNotDone) < 1)
        {
            $retorno['unRenewedItens'] = 'null';
        }
        else
        {
            $retorno['unRenewedItens'] = implode(',', $renNotDone);
        }

        $retorno['screenMsg'] = implode('\n', $sMsg);
        $retorno['printMsg'] = 'null';
        
        $backInfo = implode(SIP_DELIMITER, $retorno);
        
        $endTime = microtime(true);
        $time = $endTime - $startTime;
        MUtil::flog("Operação realizada em : " . $time);
        
        MUtil::flog($backInfo);
        return $backInfo;
    }
    
    /*
     * Esqueleto de PATRONINFO, retorno String
     * Parametros:
     * 
     * String dateTime, 
     * String summary, 
     * String instID, 
     * String patronID, 
     * String patronPwd, 
     * String termID, 
     * String termPwd, 
     * int startItem, 
     * int endItem
     * 
     * Descrição:
     *      
     * 
     * Criado por: 
     * Em: 
     * Ultima Atualização por: 
     * Em: 
     * Motivo: 
     */
    public function patronInfo($language, $dateTime, $summary, $instID, $patronID, $patronPwd, $termID, $termPwd, $startItem, $endItem ) 
    {        
        MUtil::flog("========= Operação PAtronInfo ---------------");
        $startTime = microtime(true);
        
        MUtil::flog("Iniciando Informações de usuário");
        
        $isPerson = $this->busAuthenticate->authenticate($patronID, $patronPwd);
        //$isPerson = $this->busPerson->authenticate($patronID, $patronPwd);
        $data = GDate::getYYYYMMDDHHMMSS($dateTime);        
        
        $patronStatus = Array();
        
        $hItens = Array();
        $oItens = Array();
        $cItens = Array();
        $fItens = Array();
        $rItens = Array();
        $uItens = Array();
        
        //Variáveis para contadores
        $holdItensCount = 0; //Reservas Solicitadas
        $overdueItensCount = 0; //Emprestimos atrasados
        $chargedItensCount = 0; //Itens com o usuário
        $fineItensCount = 0; //Multas para o usuario
        $recallItensCount = 0; //Itens que a biblioteca quer devolta
        //* Este campo abaixo não será utilizado no Gnuteca. *//
        $uHoldItensCount = 0; //Indisponíveis na biblioteca
        
        //Tenta se logar, verifica se o usuário existe
        
        if($isPerson)
        {
            $person = $this->busPerson->getPerson($patronID);
            if($person)
            {
                $nome = $person->personName;
                $local = $person->cityName;
                $phone = $person->phone;
                foreach($phone as $ph)
                {
                    $fone[] = $ph->phone;
                }
                $phone = implode(',', $fone);
            }
            
            //Define o grupo de maior prioridade do usuário
            $link = $this->busBond->getActivePersonLink($patronID);
            //Realiza pesquisa para obter as politicas
            $policy = $this->busPolicy->getUserPolicy($instID, $patronID, $link->activelink);
            //Define os valores
            $holdItensLimit = $policy[0]->reserveLimit;
            $chargedItensLimit = $policy[0]->loanLimit;
            
            //Instanciando o objeto busRight para realizar a pesquisa
            $this->busRight->linkId = $link->activelink;
            //Atribui valor 1, pois é refente à livro
            $this->busRight->materialGenderId = 1;
            $this->busRight->operationId = ID_OPERATION_LOAN;
            
            //Verifica se encontra direito de empréstimo ao usuário
            $right = $this->busRight->verifyRightSip();
            
            //Se tiver direito, seta o valor de limite de atraso
            if($right)
            {
                $overdueItensLimit = $policy[0]->loanLimit;
            }
            else
            {
                $overdueItensLimit = 0;
            }
            
            //Variaveis para serem utilizadas nos métodos Staticos
            $linkPessoa = $link->activelink; //LINK
            
            
            //Valores no retorno Patron Status
            //
            //0- Direito de empréstimo negado e 
            //1- Renovação negado
            
            $rightLoan = $comPenal = GSipCirculation::getRightWith('l', $patronID, $linkPessoa, ID_OPERATION_LOAN, NULL );
            
            if(!rightLoan)
            {
                //Não tem direito a empréstimo
                MUtil::flog("Grupo do usuario não tem direito a empréstimo.");
                $patronStatus[] = '0';
                $patronStatus[] = '1';
                
            }else
            {
                //verificar se tem penalidade
                $comPenal = GSipCirculation::getRightWith('p', $patronID, $linkPessoa, ID_OPERATION_LOAN_PENALTY, NULL );
                if($comPenal)
                {
                    $patronStatus[] = '0';
                    $patronStatus[] = '1';
                }
                else{
                    //verificando se tem multa ( verifica apenas com status: aberta )
                    
                    $comMulta = GSipCirculation::getRightWith('f', $patronID, $linkPessoa, ID_OPERATION_LOAN_FINE, $instID);
                    if($comMulta)
                    {
                        $patronStatus[] = '0';
                        $patronStatus[] = '1';
                    }
                }
            }
            
            //2- Direito de pedir o item devolta negado
                //Não existe atualmente no Gnuteca
            
            
            //3- Direito de reserva negado
            $fazRen = GSipCirculation::getRightWith('l', $patronID, $linkPessoa, ID_OPERATION_LOCAL_RESERVE, NULL);
            if(!$fazRen)
            {
                $patronStatus[] = '3';
            }
            
            //4- Cartão dado como perdido
                //Ainda não disponivel no Gnuteca, não será implementado.
            
            
            //5- Estorou limite de empréstimos
            $this->busLoan->personId = $patronID;
            $this->busLoan->orderByLibraryUnit = TRUE;
            $emp = $this->busLoan->getLoansOpen();
            //Contador para ver numero de emprestimos atuais
            $empN = 0;
            foreach($emp as $c)
            {
                $empN++;
            }
            if($chargedItensLimit <= $empN)
            {
                $patronStatus[] = '5';
            }
            
            
            //6- Estorou limite de atrasos
            if($overdueItensLimit > $policy[0]->loanLimit)
            {
                $patronStatus[] = '6';
            }
            
            
            //7- Estorou limite de renovações
                //Usuario nao possui limite de renovações
            
            
            //8- Muitas reclamações de itens devolvidos
            $comRecl = GSipCirculation::getRightWith('p',  $patronID, $linkPessoa, ID_OPERATION_LOAN_PENALTY, NULL );
            if($comRecl)
            {
                MUtil::flog("penalidades");
                $patronStatus[] = '8';
            }
            
            
            //9- Estorou limite de itens perdidos
                //Gnuteca não tem essa funcionalidade
            

            //10- Multas excessivas em circulação (Mostrará apenas as com status : Aberta
            $comFine = GSipCirculation::getRightWith('f',  $patronID, $linkPessoa, ID_OPERATION_LOAN_FINE, $instID);
            if($comFine)
            {
                MUtil::flog("multas");
                $patronStatus[] = '10';
            }
            
            
            //11- Penalidades excessivas em circulação
            $comPenal = GSipCirculation::getRightWith('p',  $patronID, $linkPessoa, ID_OPERATION_LOAN_PENALTY, NULL);
            if($comPenal)
            {
                MUtil::flog("penalidades 11");
                $patronStatus[] = '11';
            }
            
            //12- Devolver para a biblioteca com atraso
            
            
            //13- Muitas faturas
            $patronStatus = implode('.', $patronStatus);
            
            //Verificar as operações que irá fazerM
            $hold = stripos($summary, 'H');
            $overdue = stripos($summary, 'O');
            $charged = stripos($summary, 'C');
            $fine = stripos($summary, 'F');
            $recall = stripos($summary, 'R');
            $unavailable = stripos($summary, 'U');

            //Reservas feitas pelo usuário
            if($hold !== FALSE)
            {
                //Define a pessoa
                $this->busReserve->personId = $person->personId;
                //Apenas irá trazer as reservas solicitadas
                $this->busReserve->reserveTypeIdS = ID_RESERVESTATUS_REQUESTED;
                //Pegando as reservas para a variavel
                $reservas = $this->busReserve->searchReserve();

                foreach($reservas as $r)
                {
                    $this->busReserveComposition->reserveId = $r[0];
                    $this->busReserveComposition->reserveIdS = $r[0];
                    $var = $this->busReserveComposition->searchReserveComposition(TRUE);

                    foreach($var as $v)
                    {
                        //Poe na lista
                        $hItens[] = $v->itemNumber;
                        //Incrementa contador
                        $holdItensCount++;
                    }
                }
                $holdItens = implode(',', $hItens);
            }

            //Itens que já passaram da data de entrega
            if($overdue !== FALSE)
            {
                //seta User
                $this->busLoan->personId = $patronID;
                //seta Data
                $now = GDate::now();
                $now->setHour('00');
                $now->setMinute('00');
                $now->setSecond('00');
                $now = $now->getDate(GDate::MASK_TIMESTAMP_USER);
                $this->busLoan->returnForecastDate = $now;

                //Busca todos os empréstimos atrasados
                $loans = $this->busLoan->getDelayedLoanByUser();         

                //Se não tiver nenhum material atrasado neste período
                if ( $loans )
                {
                    foreach($loans as $l)
                    {
                        $overdueItensCount++;
                        $oItens[] = $l->itemNumber;
                    }
                }
                $overdueItens = implode(',', $oItens);
            }
            
            //Itens que estão com o usuário
            if($charged !== FALSE)
            {
                $this->busLoan->personId = $patronID;
                $this->busLoan->orderByLibraryUnit = TRUE;
                $var = $this->busLoan->getLoansOpen();
                foreach($var as $loan)
                {
                    $chargedItensCount++;
                    $cItens[] = $loan->itemNumber;
                }
                $chargedItens = implode(',', $cItens);
            }
            
            //Itens que serão cobrados multa
            if($fine !== FALSE)
            {
                $this->busFine->personId = $patronID;
                $this->busFine->personIdS = $patronID;
                
                $fAberta = $this->busFine->searchFine(TRUE);
                
                if($fAberta)
                {
                    foreach($fAberta as $f)
                    {
                        if($f->endDate == NULL)
                        {
                            $loan = $this->busLoan->getLoan($f->loanId, TRUE);
                            $fItens[] = $loan->itemNumber;
                            $fineItensCount++;
                        }
                    }
                    $fineItens = implode(',', $fItens);
                }
            }
            
            //Livros que estão com o usuario e a biblioteca solicita devolta
            if($recall !== FALSE)
            {
                $this->busLoan->personId = $patronID;
                $this->busLoan->orderByLibraryUnit = TRUE;
                $var = $this->busLoan->getLoansOpen();

                foreach($var as $loan)
                {
                    //Apenas irá contabilizar as reservas requeridas
                    if($this->busReserve->hasReserve($loan->itemNumber, ID_RESERVESTATUS_REQUESTED))
                    {
                        $rItens[] = $loan->itemNumber;
                        $recallItensCount++;
                    }
                }
                $recallItens = implode(',', $rItens);
            }
            
            //Livros reservados que não estão disponíveis na biblioteca
            if($unavailable !== FALSE)
            {
                //Não acontece no Gnuteca, e não será utilizado
            }
            
            //Verificações para ver se não estão vazias
            if(empty($patronStatus))
            {
                $patronStatus = 'null';
            }
            if(empty($holdItens))
            {
                $holdItens = 'null';
            }
            if(empty($overdueItens))
            {
                $overdueItens = 'null';
            }
            if(empty($chargedItens))
            {
                $chargedItens = 'null';
            }
            if(empty($fineItens))
            {
                $fineItens = 'null';
            }
            if(empty($recallItens))
            {
                $recallItens = 'null';
            }
            if(empty($phone))
            {
                $phone = 'null';
            }
            
            //Montagem do retorno
            
            $retorno['patronStatus'] = $patronStatus;
            $retorno['language'] = '10';
            $retorno['dateTime'] = $data;
            $retorno['holdItensCount'] = $holdItensCount;
            $retorno['overdueItensCount'] = $overdueItensCount;
            $retorno['chargedItensCount'] = $chargedItensCount;
            $retorno['fineItensCount'] = $fineItensCount;
            $retorno['recallItensCount'] = $recallItensCount;
            $retorno['uHoldsItensCount'] = $uHoldItensCount;
            
            $retorno['instID'] = $instID;
            $retorno['patronID'] = $patronID;
            $retorno['personalName'] = $nome;

            $retorno['holdItensLimit'] = $holdItensLimit;
            $retorno['overdueItensLimit'] = $overdueItensLimit;
            $retorno['chargedItensLimit'] = $chargedItensLimit;
            
            $retorno['validPatron'] = 'Y';
            $retorno['validPatronPwd'] = 'Y';
            
            $retorno['holdItens'] = $holdItens;
            $retorno['overdueItens'] = $overdueItens;
            $retorno['chargedItens'] = $chargedItens;
            $retorno['fineItens'] = $fineItens;
            $retorno['recallItens'] = $recallItens;
            $retorno['uHoldItens'] = 'null';
            $retorno['homeAdress'] = $local;
            $retorno['homePhone'] = $phone;
            $retorno['screenMsg'] = 'Usuário encontrado.';
            $retorno['printMsg'] = 'null';
        }
        else
        {
            $retorno['patronStatus'] = 'null';
            $retorno['language'] = '10';
            $retorno['dateTime'] = $data;
            $retorno['holdItensCount'] = $holdItensCount;
            $retorno['overdueItensCount'] = $overdueItensCount;
            $retorno['chargedItensCount'] = $chargedItensCount;
            $retorno['fineItensCount'] = $fineItensCount;
            $retorno['recallItensCount'] = $recallItensCount;
            $retorno['uHoldsItensCount'] = $uHoldItensCount;
            
            $retorno['instID'] = $instID;
            $retorno['patronID'] = $patronID;
            $retorno['personalName'] = 'null';
            
            $retorno['holdItensLimit'] = 'NULL';
            $retorno['overdueItensLimit'] = 'NULL';
            $retorno['chargedItensLimit'] = 'NULL';
            
            $retorno['validPatron'] = 'N';
            $retorno['validPatronPwd'] = 'NULL';
            
            $retorno['holdItens'] = $holdItens;
            $retorno['overdueItens'] = $overdueItens;
            $retorno['chargedItens'] = $chargedItens;
            $retorno['fineItens'] = $fineItens;
            $retorno['recallItens'] = $recallItens;
            $retorno['uHoldItens'] = 'null';
            $retorno['homeAdress'] = 'null';
            $retorno['homePhone'] = 'null';
            
            $retorno['screenMsg'] = 'Sem informações desse usuário.';
            $retorno['printMsg'] = 'null';
        }
        $backInfo = implode(SIP_DELIMITER, $retorno);
        
        $endTime = microtime(true);
        $time = $endTime - $startTime;
        MUtil::flog("Operação realizada em : " . $time);
        
        MUtil::flog($backInfo);
        return $backInfo;
    }
}
?>