PHP Transaction::rollback方法代码示例

 /**
  * @param User $user
  * @param Invitation $invitation
  * @return void
  * @throws Runtime\DuplicateUsernameException
  * @throws Runtime\DuplicateEmailException
  * @throws Runtime\InvitationNotFoundException
  * @throws Runtime\InvitationExpiredException
  * @throws Runtime\InvitationTokenMatchException
  * @throws \DibiException
  */
 public function registerNewUser(User $user, Invitation $invitation)
 {
     if (!$user->isDetached()) {
         throw new InvalidArgumentException('Only detached instances of Entity ' . User::class . ' can pass.');
     }
     $this->checkInvitation($user->email, $invitation->token);
     try {
         $this->transaction->begin();
         $this->userRepository->persist($user);
         $this->removeInvitation($invitation);
         $this->transaction->commit();
     } catch (\DibiException $e) {
         if ($e->getCode() == 1062) {
             try {
                 $this->userRepository->checkUsername($user->username);
             } catch (Runtime\UserAlreadyExistsException $usernameException) {
                 $this->transaction->rollback();
                 throw new Runtime\DuplicateUsernameException();
             }
             try {
                 $this->userRepository->checkEmail($user->email);
             } catch (Runtime\UserAlreadyExistsException $emailException) {
                 $this->transaction->rollback();
                 throw new Runtime\DuplicateEmailException();
             }
         }
         $this->transaction->rollback();
         Debugger::log($e, Debugger::ERROR);
         throw $e;
     }
 }

 /**
  * Override BundlableLabelableBaseModelWithAttributes::changeType() to update
  * current location "subclass" (ie. type) value when type change is used.
  * This should be invoked by any model that can be used to indicate object
  * storage location. This includes, for now at least, ca_loans, ca_movements, 
  * ca_occurrences and ca_objects_x_storage_locations.
  *
  * @param mixed $pm_type The type_id or code to change the current type to
  * @return bool True if change succeeded, false if error
  */
 public function changeType($pm_type)
 {
     if (!$this->getPrimaryKey()) {
         return false;
     }
     // row must be loaded
     if (!($vb_already_in_transaction = $this->inTransaction())) {
         $this->setTransaction($o_t = new Transaction($this->getDb()));
     }
     if ($vn_rc = parent::changeType($pm_type)) {
         $o_db = $this->getDb();
         $o_db->query("\n\t\t\t\t\tUPDATE ca_objects SET current_loc_subclass = ? \n\t\t\t\t\tWHERE \n\t\t\t\t\t\tcurrent_loc_class = ? AND current_loc_id = ?\n\t\t\t\t", array($this->get('type_id'), $this->tableNum(), $this->getPrimaryKey()));
         if ($o_db->numErrors()) {
             $this->errors = $o_db->errors;
             if (!$vb_already_in_transaction) {
                 $o_t->rollback();
             }
             return false;
         }
     }
     if (!$vb_already_in_transaction) {
         $o_t->commit();
     }
     return $vn_rc;
 }

 /**
  * @param ListingItem $listingItem
  * @return ListingItem
  * @throws ListingItemDayAlreadyExistsException
  * @throws \DibiException
  */
 public function saveListingItem(ListingItem $listingItem)
 {
     try {
         $this->transaction->begin();
         $this->listingItemRepository->persist($listingItem);
         $this->localityRepository->saveLocalityToUserList($listingItem->locality, $listingItem->listing->getRowData()['userID']);
         $this->transaction->commit();
         return $listingItem;
     } catch (\DibiException $e) {
         $this->transaction->rollback();
         if ($e->getCode() == 1062) {
             throw new ListingItemDayAlreadyExistsException();
         }
         Debugger::log($e, Debugger::ERROR);
         throw $e;
     }
 }

function deleteWidget($id)
{
    try {
        $transaction = new Transaction();
        $result = DAOFactory::getAfiliadoWidgetDAO()->delete($id);
        $transaction->commit();
        return $result;
    } catch (Exception $e) {
        print_r($e);
        if ($transaction) {
            $transaction->rollback();
        }
        return false;
    }
}

 public function rollback($auth = NULL)
 {
     if ($auth != Transaction::SIGNATURE) {
         return Transaction::rollback();
     }
     if (!$this->txn) {
         return FALSE;
     }
     if ($this->lock) {
         return TRUE;
     }
     $rs = (bool) $this->__call(__FUNCTION__, array());
     $this->lock = TRUE;
     return $rs;
 }

function deleteFaq($id)
{
    try {
        $transaction = new Transaction();
        $faq = DAOFactory::getFaqDAO()->load($id);
        DAOFactory::getFaqDAO()->delete($id);
        $transaction->commit();
        return true;
    } catch (Exception $e) {
        var_dump($e);
        if ($transaction) {
            $transaction->rollback();
        }
        return false;
    }
}

function insertBusquedaDisponibilidad($data)
{
    try {
        $transaction = new Transaction();
        $busqueda = DAOFactory::getBusquedaDisponibilidadDAO()->prepare($data);
        $id = DAOFactory::getBusquedaDisponibilidadDAO()->insert($busqueda);
        $transaction->commit();
        return $id;
    } catch (Exception $e) {
        var_dump($e);
        if ($transaction) {
            $transaction->rollback();
        }
        return false;
    }
}

 /**
  * @param array $messages Key => recipientID, Value = Message entity or array of messages
  * @throws InvalidArgumentException
  * @throws \DibiException
  * @return array
  */
 public function sendMessages(array $messages)
 {
     $ex = new InvalidArgumentException('Only non-persisted instances of ' . Message::class . ' can pas.');
     $msgs = [];
     foreach ($messages as $recipientID => $recipientMessages) {
         Validators::assert($recipientID, 'numericint');
         if (is_array($recipientMessages)) {
             foreach ($recipientMessages as $message) {
                 if (!($message instanceof Message and $message->isDetached())) {
                     throw $ex;
                 }
                 $msgs[] = $message;
             }
         } else {
             // recipientMessages contains only one message
             if (!($recipientMessages instanceof Message and $recipientMessages->isDetached())) {
                 throw $ex;
             }
             $msgs[] = $recipientMessages;
         }
     }
     try {
         $this->transaction->begin();
         $this->messageRepository->saveMessages($msgs);
         unset($msgs);
         $usersMessages = [];
         foreach ($messages as $recipientID => $recipientMessages) {
             if (is_array($recipientMessages)) {
                 foreach ($recipientMessages as $message) {
                     $recipientMessage = new UserMessage($message, $recipientID);
                     $usersMessages[] = $recipientMessage;
                 }
             } else {
                 $recipientMessage = new UserMessage($recipientMessages, $recipientID);
                 $usersMessages[] = $recipientMessage;
             }
         }
         $this->userMessageRepository->sendMessagesToRecipients($usersMessages);
         $this->transaction->commit();
         return $usersMessages;
     } catch (\DibiException $e) {
         $this->transaction->rollback();
         Debugger::log($e, Debugger::ERROR);
         throw $e;
     }
 }

 public function action_update(Params $param)
 {
     $this->content->bind('form', $torn);
     $project = Jelly::select('project')->link($param->id)->load();
     if (!$project->loaded()) {
         throw new Error404_Exception();
     }
     $torn = new Torn($project);
     if ($torn->check()) {
         try {
             Transaction::begin();
             $project->set($_FILES + $_POST);
             $project->save();
             Transaction::commit();
             $this->request->redirect(Route::get('protected')->uri(array('controller' => 'project')));
         } catch (Validate_Exception $e) {
             Transaction::rollback();
             $torn->catch_errors($e);
         }
     }
 }

function updateFactura($id, $data = array(), $trasactional = true)
{
    try {
        if ($trasactional) {
            $transaction = new Transaction();
        }
        $factura = getFactura($id);
        $factura = DAOFactory::getFacturaDAO()->prepare($data, $id);
        DAOFactory::getFacturaDAO()->update($factura);
        if ($trasactional) {
            $transaction->commit();
        }
        return true;
    } catch (Exception $e) {
        var_dump($e);
        if ($transaction) {
            $transaction->rollback();
        }
        return false;
    }
}

function updateCart($idCart, $data = array())
{
    try {
        $transaction = new Transaction();
        if (isset($data['apartamento'])) {
            $data['apartamento'] = json_encode($data['apartamento']);
        }
        if (isset($data['excursiones'])) {
            $data['excursiones'] = json_encode($data['excursiones']);
        }
        //print_r($data);
        $cart = DAOFactory::getShoppingCartDAO()->prepare($data, $idCart);
        DAOFactory::getShoppingCartDAO()->update($cart);
        $transaction->commit();
        return $idCart;
    } catch (Exception $e) {
        print_r($e);
        if ($transaction) {
            $transaction->rollback();
        }
        return false;
    }
}

function updateDireccionByHotelId($idHotel, $data = array())
{
    try {
        $transaction = new Transaction();
        $hotel = getHotelById($idHotel);
        if ($hotel->direccion) {
            updateDireccion($hotel->direccion->id, $data);
        } else {
            $dir = DAOFactory::getDireccionDAO()->prepare($data);
            $dir_id = DAOFactory::getDireccionDAO()->insert($dir);
            $hd = DAOFactory::getHotelDireccionDAO()->prepare(array('hotelId' => $hotel->id, 'direccionId' => $dir_id));
            DAOFactory::getHotelDireccionDAO()->insert($hd);
        }
        $transaction->commit();
        return $idDireccion;
    } catch (Exception $e) {
        print_r($e);
        if ($transaction) {
            $transaction->rollback();
        }
        return false;
    }
}

 /**
  * @param Listing $baseListing
  * @param Listing $listingToMerge
  * @param array $selectedCollisionItems
  * @param \App\Model\Entities\User|int|null $user
  * @return Listing
  * @throws NoCollisionListingItemSelectedException
  * @throws \DibiException
  */
 public function mergeListings(Listing $baseListing, Listing $listingToMerge, array $selectedCollisionItems = [], $user = null)
 {
     $this->checkListingValidity($baseListing);
     $this->checkListingValidity($listingToMerge);
     if (!$this->haveListingsSamePeriod($baseListing, $listingToMerge)) {
         throw new InvalidArgumentException('Given Listings must have same Period(Year and Month).');
     }
     $userID = $this->getIdOfSignedInUserOnNull($user);
     $items = $this->itemService->getMergedListOfItems($baseListing, $listingToMerge, $selectedCollisionItems);
     try {
         $this->transaction->begin();
         $newListing = new Listing($baseListing->year, $baseListing->month, $userID);
         $this->saveListing($newListing);
         $this->itemService->setListingForGivenItems($items, $newListing);
         $this->listingItemRepository->saveListingItems($items);
         $this->transaction->commit();
         return $newListing;
     } catch (\DibiException $e) {
         $this->transaction->rollback();
         Debugger::log($e, Debugger::ERROR);
         throw $e;
     }
 }

function updatePromocionPalabrasClave($id, $data = array(), $data_hoteles = array())
{
    try {
        $transaction = new Transaction();
        $promocion = DAOFactory::getPromocionPalabrasClavesDAO()->prepare($data, $id);
        DAOFactory::getPromocionPalabrasClavesDAO()->update($promocion);
        DAOFactory::getPromocionPalabrasClavesHotelDAO()->deleteByPromocionId($id);
        if ($data_hoteles && is_array($data_hoteles) && count($data_hoteles)) {
            foreach ($data_hoteles as $hid) {
                $hotel_promo = DAOFactory::getPromocionPalabrasClavesHotelDAO()->prepare(array('promocionId' => $id, 'hotelId' => $hid));
                DAOFactory::getPromocionPalabrasClavesHotelDAO()->insert($hotel_promo);
            }
        }
        $transaction->commit();
        return true;
    } catch (Exception $e) {
        error_log($e);
        if ($transaction) {
            $transaction->rollback();
        }
        return false;
    }
}

function updateDominioCampania($idCampania, $dominio)
{
    try {
        $transaction = new Transaction();
        $data = array('subdominio' => $dominio);
        $campania = DAOFactory::getCampaniaDAO()->prepare($data, $idCampania);
        DAOFactory::getCampaniaDAO()->update($campania);
        $transaction->commit();
        return true;
    } catch (Exception $e) {
        var_dump($e);
        if ($transaction) {
            $transaction->rollback();
        }
        return false;
    }
}