lib/Tiempo/Banda.php

   1 <?php
   2 // vim: set expandtab tabstop=4 softtabstop=4 shiftwidth=4:
   3 // +--------------------------------------------------------------------+
   4 // |                          HORAS EXTRA                               |
   5 // +--------------------------------------------------------------------+
   6 // |    Sistema de Horas Extra - Ministerio de Economía - Argentina     |
   7 // +--------------------------------------------------------------------+
   8 // | Creado: lun abr 22 16:05:33 ART 2002                               |
   9 // | Autor:  Gonzalo Merayo <gmeray@mecon.gov.ar>                    |
  10 // +--------------------------------------------------------------------+
  11 //
  12 // $URL$
  13 // $Rev$
  14 // $Date$
  15 // $Author$
  16 //
  17
  18 require_once 'HE/Intervalo.php';
  19
  20 /**
  21  * Representa un conjunto de entradas y salidas para formar una banda horaria
  22  *
  23  * @package HE
  24  * @abstract
  25  * @version $Rev$
  26  * @author  Gonzalo Merayo <gmeray@mecon.gov.ar>
  27  */
  28 class Banda {
  29
  30   var $intervalos;
  31
  32   function Banda() {
  33     $this->intervalos = array();
  34   }
  35
  36   function Cargar($agente, $fecha)
  37   {
  38     $dsn = "mysql://intranet:intranet@intranet-db/bandas";
  39     $db = DB::connect( $dsn , true);
  40     if(DB::isError($db))
  41       die($db->getMessage());
  42     $fecha = $fecha->format("%Y%m%d");
  43     $query = "SELECT A.tipo_acceso, A.hora
  44               FROM agentes G, accesos A
  45               WHERE G.cred = A.cred
  46               AND G.docu = $agente
  47               AND A.fecha = $fecha
  48               AND A.inconsistencia = 0
  49               ORDER BY A.hora";
  50     $result = $db->query($query);
  51     if(DB::isError($result))
  52       die($result->getMessage());
  53
  54     $sip     =& new HE_DB_Persona;
  55     $datos   = $sip->obtener($agente);
  56     $age     =& new HE_DB_Agente;
  57     $ag      = $age->obtener($agente, $datos['codep']);
  58     $funcion = @$ag['funcion'];
  59
  60     if($funcion != 'SE')
  61     {//Version tough
  62       $int == null;
  63       while( $r = $result->fetchRow() )
  64       {
  65         if($r[0] == 'E') $int = new Intervalo(new Hora( $r[1] ), new Hora( $r[1] ));
  66         if($r[0] == 'S' && $int != null)
  67         {
  68           $int->setFin( new Hora( $r[1] ) );
  69           $this->agregarIntervalo( $int );
  70           $int = null;
  71         }
  72       }
  73     }
  74     else
  75     {
  76       if($result->numRows() > 0)
  77       {//Version Light o Serenos
  78         $int = new Intervalo(new Hora('00:00'), new Hora('00:00'));
  79         while( $r = $result->fetchRow() )
  80         {
  81           if($r[0] == 'E') $int = new Intervalo(new Hora( $r[1] ), new Hora( $r[1] ));
  82           if($r[0] == 'S' && $int != null)
  83           {
  84             $int->setFin( new Hora( $r[1] ) );
  85             $this->agregarIntervalo( $int );
  86             $int = null;
  87           }
  88         }
  89         if($int != null)
  90         {
  91           $int->setFin( new Hora('24:00') );
  92           $this->agregarIntervalo( $int );
  93           $int = null;
  94         }
  95       }
  96     }
  97   }
  98
  99   /*
 100   *
 101   * Completa las salidas del medio del dia.
 102   *
 103   */
 104   function CompletarSalidas()
 105   {
 106     if(count($this->intervalos) > 0)
 107     {
 108       $p = reset($this->intervalos);
 109       $u = end($this->intervalos);
 110       $p->setFin($u->fin);
 111       $this->intervalos = array($p);
 112     }
 113   }
 114
 115
 116   /**
 117   * Agrega un intervalo a la banda
 118   * Chequeando superposiciones y en orden
 119   *
 120   * @param Intervalo $intervalo Intervalo a agregar.
 121   */
 122   function agregarIntervalo($intervalo)
 123   {
 124     if(! is_a($intervalo, "intervalo")) return false;
 125     if ($intervalo->invertido()) {
 126         $intervalo->_chequear();
 127         $this->agregarIntervalo(new Intervalo(new Hora('00:00'), new Hora ('24:00')));
 128         $this->sacarIntervalo($intervalo);
 129         return true;
 130     }
 131     $n_intervalos = array();
 132     $insertado = false;
 133     // recorre el vector de intervalos
 134     foreach( $this->intervalos as $i )
 135     {
 136       // si se superpone con alguno, fusionar con ese
 137       if($i->seSuperpone($intervalo))
 138         $intervalo->fusionar($i);
 139       else{
 140         if($i->inicio->greater($intervalo->inicio) && ! $insertado)
 141         {
 142           array_push($n_intervalos, $intervalo);
 143           $insertado = true;
 144         }
 145         array_push($n_intervalos, $i);
 146       }
 147     }
 148     if(! $insertado ) array_push($n_intervalos,$intervalo);
 149     $this->intervalos = $n_intervalos;
 150     return true;
 151   }
 152
 153   /**
 154   * Saca
 155   *
 156   *
 157   */
 158   function sacarBanda($banda)
 159   {
 160     foreach($banda->intervalos as $i)
 161       $this->sacarIntervalo($i);
 162   }
 163
 164   /**
 165   * Saca un intervalo de una banda horaria.
 166   *
 167   */
 168   function sacarIntervalo($intervalo)
 169   {
 170     if(! is_a($intervalo, "intervalo")) return false;
 171     // Si el intervalo está vacío, no hace nada.
 172     $dur = $intervalo->getDuracion();
 173     if ($dur->isEmpty()) {
 174         return true;
 175     }
 176     $n_intervalos = array();
 177     // recorre el vector de intervalos
 178     foreach( $this->intervalos as $i )
 179     {
 180       if($i->seSuperpone($intervalo)) {
 181         $a = $i->cortar($intervalo);
 182         $d = $a->getDuracion();
 183         if($d->toSeconds() > 0) {
 184           $n_intervalos[] = $a;
 185         }
 186         $d = $i->getDuracion();
 187         if($d->toSeconds() > 0) {
 188           $n_intervalos[] = $i;
 189         }
 190       } else {
 191         $n_intervalos[] = $i;
 192       }
 193     }
 194     $this->intervalos = $n_intervalos;
 195     return true;
 196
 197   }
 198
 199   function sacarTiempo($t)
 200   {
 201     if(! is_a($t, "time_span")) return false;
 202     $n_int = array();
 203     while(count($this->intervalos) > 0)
 204     {
 205       $int = array_shift($this->intervalos);
 206       if($t->toSeconds() > 0){
 207         $d = $int->getDuracion();
 208         if($d->greater($t))
 209         {
 210           #con cortar alcanza
 211           $ini = new Hora();
 212           $ini->copy($int->inicio);
 213           $ini->add($t);
 214           /*TODO guardar este tiempo como rechazado*/$int->cortar($ini);
 215           $t->setFromSeconds(0);
 216         }else{
 217           #con cortar no alcanza y hay que sacar...
 218           $t->subtract($int->getDuracion());
 219           /*TODO guardar int como rechazado*/
 220         }
 221       }
 222       $n_int[] = $int;
 223     }
 224     $this->intervalos = $n_int;
 225   }
 226
 227   /*
 228   * Chequea si el intervalo pedido esta cubierto por la banda, si faltan
 229   *  horas en la banta se retorna el tiempo que falta
 230   *
 231   * @return Time_Span el periodo faltante
 232   *
 233   */
 234   function chequearIntervalo($intervalo)
 235   {
 236     if(! is_a($intervalo, "intervalo")) return false;
 237     $t = new Hora();
 238     foreach ($this->intervalos as $i)
 239       $t->add($i->superponer($intervalo));
 240     $d = $intervalo->getDuracion();
 241     $d->subtract($t);
 242     return $d;
 243   }
 244
 245   /*
 246   * Chequea si la banda(parametro) esta cubierto por la banda(this),
 247   *  si faltan horas en la banda(this) para llegar a banda(parametro)
 248   *  se retorna el tiempo que falta
 249   *
 250   * @return Time_Span el periodo faltante
 251   *
 252   */
 253   function chequearBanda($banda)
 254   {
 255     if(! is_a($banda, "banda")) return false;
 256     $f = new Hora();
 257     foreach ($banda->intervalos as $i)
 258       $f->add($this->chequearIntervalo($i));
 259     return $f;
 260   }
 261
 262
 263   /*
 264   * Devuelve una representacion del objeto como un string.
 265   *
 266   * @return string Representacion del objeto.
 267   *
 268   */
 269   function toString()
 270   {
 271     $s = '';
 272     $t = count($this->intervalos);
 273     for ($n = 0; $n < ($t - 1); $n++) {
 274         $s .= "intervalo $n: [" . $this->intervalos[$n]->toString() . '] | ';
 275     }
 276     $n = $t - 1;
 277     if ($n != -1) {
 278         $s .= "intervalo $n: [" . $this->intervalos[$n]->toString() . ']';
 279     }
 280     return $s;
 281   }
 282
 283   function getIntervalos() {
 284     return $this->intervalos;
 285   }
 286
 287   /**
 288    * Corta una banda, devolviendo la banda previa al punto de corte.
 289    *
 290    * La banda actual queda con los intervalos posteriores al punto de corte
 291    * y se devuelve la banda con los intervalos anteriores.
 292    * El punto de corte puede ser tanto una hora como un intervalo.
 293    *
 294    * @param mixed $c Donde cortar.
 295    *
 296    * @return object Banda Bnada anterior al punto de corte.
 297    */
 298   function cortar($c)
 299   {
 300     if(!is_a($c, 'hora') and !is_a($c, 'intervalo')) return false;
 301     $b = $this->__clone();
 302     $b->intervalos = array();
 303     $intervalos = array();
 304     foreach ($this->intervalos as $i) {
 305       $a = $i->cortar($c);
 306       $da = $a->getDuracion();
 307       if (!$da->isEmpty()) {
 308         $b->agregarIntervalo($a);
 309       }
 310       $di = $i->getDuracion();
 311       if (!$di->isEmpty()) {
 312         $intervalos[] = $i;
 313       }
 314     }
 315     $this->intervalos = $intervalos;
 316     return $b;
 317   }
 318
 319   /**
 320    * Devuelve el timpo total que contiene la banda.
 321    *
 322    * @return object Time_Span Tiempo total.
 323    */
 324   function total() {
 325     $t = new Time_Span;
 326     foreach ($this->intervalos as $i) {
 327       $t->add($i->getDuracion());
 328     }
 329     return $t;
 330   }
 331
 332   /**
 333    * Alias de Banda::total() para compatibilidad con Intervalo.
 334    *
 335    * @return object Time_Span Tiempo total.
 336    */
 337   function getDuracion() {
 338     return $this->total();
 339   }
 340
 341   /**
 342    * Resetea la banda.
 343    */
 344   function flush() {
 345     $this->intervalos = array();
 346   }
 347
 348   function copy($b) {
 349     $this->flush();
 350     foreach ($b->intervalos as $i) {
 351       $this->intervalos[] = $i->__clone();
 352     }
 353   }
 354
 355   function __clone() {
 356     $class = get_class($this);
 357     $b = new $class;
 358     $b->copy($this);
 359     return $b;
 360   }
 361
 362 }
 363
 364 // $Id$
 365 ?>