public static function instance()
 {
     if (!isset(self::$instance)) {
         $c = __CLASS__;
         self::$instance = new $c();
     }
     return self::$instance;
 }
 /**
  * Agrega un registro a la persistencia.
  *
  * @param \TSLIDataTransferObj $dto EL DATA TRANSFER OBJECT contendra todos los
  * datos requeridos del registro a agregar, se espera como parte de los parametros
  * los datos a usarse para crear el modelo a actualizar.
  *
  * Ya sea en caso de error o no , la respuesta estara contenida en el DTO.
  *
  * @see \TSLIBasicRecordDAO
  * @see \TSLBasicRecordDAO
  */
 private function add(\TSLIDataTransferObj $dto)
 {
     // Obtengo referencia a los constraints
     $constraints =& $dto->getConstraints();
     // el modelo
     $model =& $this->getModelToAdd($dto);
     /* @var $outMessage TSLOutMessage */
     $outMessage =& $dto->getOutMessage();
     $tmg = NULL;
     try {
         $tmg = \TSLTrxFactoryManager::instance()->getTrxManager();
         $tmg->init();
         /* @var $dao \TSLIBasicRecordDAO */
         $dao = \TSLDAOLoaderHelper::loadDAO($this->IdDAOName);
         /* @var $ret string */
         $ret = $dao->add($model, $constraints);
         $CI =& get_instance();
         if ($ret === DB_ERR_ALLOK) {
             $outMessage->setSuccess(true);
             // El resultado es el modelo mismo con los datos pero el campo de version modificado.
             $outMessage->setResultData($model);
         } else {
             if ($ret == DB_ERR_RECORDEXIST) {
                 $outMessage->setSuccess(false);
                 // El resultado es el modelo mismo con los datos del registro modificados
                 $outMessage->setResultData($model);
                 $CI->lang->load($this->IdMSGLanguage);
                 $outMessage->setAnswerMessage($CI->lang->line($this->msgPrefix . '_rec_alreadyexist'), $ret);
             } else {
                 if ($ret == DB_ERR_FOREIGNKEY) {
                     $outMessage->setSuccess(false);
                     $CI->lang->load($this->IdMSGLanguage);
                     $outMessage->setAnswerMessage($CI->lang->line($this->msgPrefix . '_rec_foreignkey_add'), $ret);
                 } else {
                     $CI->lang->load($this->IdMSGLanguage);
                     $outMessage->setSuccess(false);
                     // Si es iactivo enviamos el mensaje respectivo
                     if ($ret == DB_ERR_RECORDINACTIVE) {
                         $outMessage->setAnswerMessage($CI->lang->line($this->msgPrefix . '_rec_inactivo'), $ret);
                     } else {
                         $outMessage->setAnswerMessage($CI->lang->line($this->msgPrefix . '_servererror'), $ret);
                     }
                 }
             }
         }
     } catch (\Exception $ex) {
         // Coloco la excepcion en el DTO.
         // TODO: Internacionalizar.
         $processError = new \TSLProcessErrorMessage($ex->getCode(), 'Error Interno', $ex);
         $outMessage->addProcessError($processError);
     }
     if ($tmg !== NULL) {
         $tmg->end();
     }
 }
 /**
  * Agrega un registro a la persistencia.
  *
  * @see TSLIBasicRecordDAO::add()
  *
  */
 public function add(\TSLDataModel &$record, \TSLRequestConstraints &$constraints = NULL)
 {
     $localTrans = FALSE;
     $ret = DB_ERR_ALLOK;
     $needRereadRecord = FALSE;
     $tmg = \TSLTrxFactoryManager::instance()->getTrxManager();
     if ($tmg->isAlreadyOpened() == FALSE) {
         $tmg->init();
         if ($tmg->isAlreadyOpened() == FALSE) {
             $ret = DB_ERR_SERVERNOTFOUND;
         } else {
             $localTrans = TRUE;
         }
     }
     $uniqueId = $record->getUniqueCode();
     if ($ret === DB_ERR_ALLOK) {
         try {
             // Aqui leemos de no exister recibiremos DB_ERR_RECORDNOTFOUND
             // de lo contrario DB_ERR_ALLOK
             // Logicamente si existe un id es casi seguro el registro ya existe
             // pero verificamos ya que podria estar eliminado entre el momento que se
             // leyo y el momento que se graba.
             if ($uniqueId != NULL) {
                 $ret = $this->getByCode($uniqueId, $record);
                 if ($ret == DB_ERR_ALLOK) {
                     $ret = DB_ERR_RECORDEXIST;
                 }
             } else {
                 $ret = DB_ERR_RECORDNOTFOUND;
             }
         } catch (Exception $ex) {
             $ret = $ex->getCode();
         }
         // Aqui para el caso exista una excepcion
         $DB = $tmg->getDB();
         // Si no existe , continuamos.
         if ($ret == DB_ERR_RECORDNOTFOUND) {
             $ret = DB_ERR_ALLOK;
             try {
                 // Trata de hacer update.
                 $query = $DB->query($this->getAddRecordQuery($record, $constraints));
                 if (!$query) {
                     if ($this->isDuplicateKeyError($DB->_error_number(), $DB->_error_message()) == TRUE) {
                         $ret = DB_ERR_RECORDEXIST;
                         //    $needRereadRecord = TRUE;
                     } else {
                         if ($this->isForeignKeyError($DB->_error_number(), $DB->_error_message()) == TRUE) {
                             $ret = DB_ERR_FOREIGNKEY;
                         } else {
                             $ret = DB_ERR_CANTEXECUTE;
                         }
                     }
                 }
                 unset($query);
             } catch (Exception $ex) {
                 $ret = $ex->getCode();
             }
             // Si no hay error o se requiere releer el registro , leemos y seteamos los ultimos valores
             if ($ret == DB_ERR_ALLOK || $needRereadRecord == TRUE) {
                 // De lo contrario actualizamos el registro con los valores actualizados
                 // esto ya que la version del record cambiara y debe ser actualizado por el
                 // lado cliente si lo cree conveniente.
                 try {
                     // Si la llave primaria es una secuencia o identidad obtenemos el ultimo valor agregado.
                     // para ser colocado en la variable uniqueId, se supone que si el caso es que usa secuencias
                     // DEBERA EXISTIR AL MENOS UNA FILA CON RESULTADOS DE NO SER ASI DARA ERROR
                     //Previamente se verifica si no se tiene ya el unique id en el cso que se trate de agregar
                     // un registro PREEXISTENTE.
                     if ($needRereadRecord === FALSE && (!isset($uniqueId) || $uniqueId === NULL)) {
                         if ($record->isPKSequenceOrIdentity() === true) {
                             $query = $DB->query($this->getLastSequenceOrIdentityQuery($record));
                             // No puede ser mas de un record !!!!
                             if ($query && $query->num_rows() === 1) {
                                 $row = $query->first_row('array');
                                 foreach ($row as $x => $x_value) {
                                     $uniqueId = $row[$x];
                                 }
                                 unset($query);
                             }
                         }
                     }
                     // Aqui leemos de no exister recibiremos DB_ERR_RECORDNOTFOUND
                     // de lo contrario DB_ERR_ALLOK
                     $ret = $this->getByCode($uniqueId, $record);
                 } catch (Exception $ex) {
                     $ret = $ex->getCode();
                 }
             }
         }
         if ($localTrans == TRUE) {
             $tmg->end();
         }
         if ($ret != DB_ERR_ALLOK && $ret != DB_ERR_RECORDEXIST && $ret != DB_ERR_RECORDINACTIVE && $ret != DB_ERR_FOREIGNKEY) {
             throw new \TSLDbException($ret == DB_ERR_CANTEXECUTE ? $DB->_error_message() . '-' . $DB->_error_number() : null, $ret);
         }
         return $ret;
     }
 }