Confirm the reservation and receive tickets
 /api/v1/reservation/{reservationKey}/confirm

 @return True (or error)
489402
def confirm_reservation(reservation_key: '', payment_method: '', amount_paid: nil)

      # step 1: confirm
      path = "reservation/#{reservation_key}/confirm"
      body = {
        PaymentMethod: payment_method,
        AmountPaid: amount_paid
      }
      call(path, http_method: :post, body: body.to_json)

      # step 2: get tickets
      # GET /api/v1/reservation/{reservationKey}/tickets
      path = "reservation/#{reservation_key}/tickets"
      result = call(path, http_method: :get)

      # define new list
      list = []

      for ticket in result
        list << ShakeTheCounter::Ticket.new(ticket)
      end
      return list
    end
772101
def complete_confirmation(self, confirmation_id, complete_dict):
        
        return self._create_put_request(
            resource=CONFIRMATIONS,
            billomat_id=confirmation_id,
            command=COMPLETE,
            send_data=complete_dict
        )
217124
def validate_proxy_granting_ticket(pgt, target_service):
    
    logger.debug("Proxy ticket request received for %s using %s" % (target_service, pgt))

    pgt = ProxyGrantingTicket.objects.validate_ticket(pgt, target_service)
    pt = ProxyTicket.objects.create_ticket(service=target_service, user=pgt.user, granted_by_pgt=pgt)
    return pt
916300
public int execute()
    {
        int executed = 0;
        final long now = now();
        sortIfNeeded();
        Set<Ticket> cancelled = new HashSet<>();
        for (Ticket ticket : this.tickets) {
            if (now - ticket.start < ticket.delay) {
                // tickets are ordered, not meeting the condition means the next ones do not as well
                break;
            }
            if (!ticket.alive) {
                //  Dead ticket, let's continue
                cancelled.add(ticket);
                continue;
            }
            ticket.alive = false;
            cancelled.add(ticket);
            ticket.handler.time(ticket.args);
            ++executed;
        }
        for (int idx = tickets.size(); idx-- > 0; ) {
            Ticket ticket = tickets.get(idx);
            if (ticket.alive) {
                break;
            }
            cancelled.add(ticket);
        }
        this.tickets.removeAll(cancelled);
        cancelled.clear();
        return executed;
    }
655310
def event_confirmation(self, date, time, pid, commerce_id, transaction_id, request_ip, order_id):
        '''
        '''
        raise NotImplementedError("Logging Handler must implement event_confirmation")
973480
def get_shake_info(self, ticket):
        
        res = self._post(
            'shakearound/user/getshakeinfo',
            data={
                'ticket': ticket
            },
            result_processor=lambda x: x['data']
        )
        return res
267135
@POST
  @Path("{id}/email/confirm")
  @PermitAll
  public Response confirmChangeEmail(@PathParam("id") Long userId, EmailRequest request) {
    checkNotNull(userId);
    checkNotNull(request.getToken());

    boolean isSuccess = userService.confirmEmailAddressChangeUsingToken(userId, request.getToken());
    return isSuccess ? Response.noContent().build() : Response.status(Response.Status.BAD_REQUEST).build();
  }
65338
def update
    if @confirmable.attempt_set_password(user_params)

      # this section is patterned off of devise 3.2.5 confirmations_controller#show

      self.resource = resource_class.confirm_by_token(params[:confirmation_token])
      yield resource if block_given?

      if resource.errors.empty?
        log_action( "invitee confirmed" )
        set_flash_message(:notice, :confirmed)
          # sign in automatically
        sign_in_tenanted_and_redirect(resource)

      else
        log_action( "invitee confirmation failed" )
        respond_with_navigational(resource.errors, :status => :unprocessable_entity){ render :new }
      end

    else
      log_action( "invitee password set failed" )
      prep_do_show()  # prep for the form
      respond_with_navigational(resource.errors, :status => :unprocessable_entity){ render :show }
    end  # if..then..else passwords are valid
  end
1050307
protected boolean isRequestAskingForServiceTicket(final RequestContext context) {
        val ticketGrantingTicketId = WebUtils.getTicketGrantingTicketId(context);
        LOGGER.debug("Located ticket-granting ticket [{}] from the request context", ticketGrantingTicketId);

        val service = WebUtils.getService(context);
        LOGGER.debug("Located service [{}] from the request context", service);

        val renewParam = getWebflowEventResolutionConfigurationContext().getCasProperties().getSso().isRenewAuthnEnabled()
            ? context.getRequestParameters().get(CasProtocolConstants.PARAMETER_RENEW)
            : StringUtils.EMPTY;
        LOGGER.debug("Provided value for [{}] request parameter is [{}]", CasProtocolConstants.PARAMETER_RENEW, renewParam);

        if (service != null && StringUtils.isNotBlank(ticketGrantingTicketId)) {
            val authn = getWebflowEventResolutionConfigurationContext().getTicketRegistrySupport().getAuthenticationFrom(ticketGrantingTicketId);
            if (StringUtils.isNotBlank(renewParam)) {
                LOGGER.debug("Request identifies itself as one asking for service tickets. Checking for authentication context validity...");
                val validAuthn = authn != null;
                if (validAuthn) {
                    LOGGER.debug("Existing authentication context linked to ticket-granting ticket [{}] is valid. "
                        + "CAS should begin to issue service tickets for [{}] once credentials are renewed", ticketGrantingTicketId, service);
                    return true;
                }
                LOGGER.debug("Existing authentication context linked to ticket-granting ticket [{}] is NOT valid. "
                        + "CAS will not issue service tickets for [{}] just yet without renewing the authentication context",
                    ticketGrantingTicketId, service);
                return false;
            }
        }

        LOGGER.debug("Request is not eligible to be issued service tickets just yet");
        return false;
    }
326852
void confirmCancel() {

        if (m_saveButton.isEnabled()) {
            CmsConfirmDialog dialog = new CmsConfirmDialog(
                org.opencms.gwt.client.Messages.get().key(org.opencms.gwt.client.Messages.GUI_DIALOG_RESET_TITLE_0),
                org.opencms.gwt.client.Messages.get().key(org.opencms.gwt.client.Messages.GUI_DIALOG_RESET_TEXT_0));
            dialog.setHandler(new I_CmsConfirmDialogHandler() {

                public void onClose() {

                    // nothing to do
                }

                public void onOk() {

                    cancelEdit();
                }
            });
            dialog.center();
        } else {
            cancelEdit();
        }
    }
1278571
public function getIsConfirmed()
    {
        $cAttribute = $this->confirmationAttribute;
        return (is_string($cAttribute) && !empty($cAttribute)) ? $this->$cAttribute > static::$confirmFalse : true;
    }
958810
public function init()
    {
        parent::init();
        $reservation = $this->getReservation();

        // If we get to the success controller form any state except PENDING or PAID
        // This would mean someone would be clever and change the url from summary to success bypassing the payment
        // End the session, thus removing the reservation, and redirect back
        if (!in_array($reservation->Status, array('PENDING', 'PAID'))) {
            ReservationSession::end();
            $this->redirect($this->Link('/'));
        } elseif ($reservation->Status !== 'PAID') {
            // todo move to TicketPayment::onCaptured()
            $this->extend('afterPaymentComplete', $reservation);
        }
    }
787108
def await_reservations(self):
    """"""
    done = False
    while not done:
      done = self._request('QUERY')
      time.sleep(1)
    return self.get_reservations()
1276823
public function confirm($id = NULL) {
        return $this->request("POST", self::URL_ORDERS . $id . "/confirm/", $api_key = $this->culqi->api_key);
    }
541651
public function confirmDelete()
    {
        if (null === $this->confirm_delete) {
            return (bool) config('cms-models.defaults.confirm_delete', false);
        }

        return (bool) $this->confirm_delete;
    }
584770
def find_reservation(key)
      path = "reservation/#{key}"
      result = call(path, http_method: :get)
      reservation = ShakeTheCounter::Reservation.new(result)
      return reservation
    end
196360
public function confirm()
    {
        Yii::$app->get('hiart')->disableAuth();

        return Client::perform('add-allowed-i-p', [
            'confirm_data' => Yii::$app->request->get(),
        ]);
    }