Sends confirmation data from request to API.
196360
public function confirm()
    {
        Yii::$app->get('hiart')->disableAuth();

        return Client::perform('add-allowed-i-p', [
            'confirm_data' => Yii::$app->request->get(),
        ]);
    }
518633
public function confirm($request, $response, $args)
    {
        $this->ci->view->render($response, 'FormGenerator/confirm.html.twig', $request->getQueryParams());
    }
806632
def post(self, request, *args, **kwargs):
        
        serializer = EventSerializer(data=request.data)

        if not serializer.is_valid():
            return Response(
                {"accepted": False, "reason": serializer.errors}, status=400
            )

        data = serializer.validated_data

        event_type = {
            "ack": "ack",
            "nack": "nack",
            "delivery_report": "delivery_succeeded",
        }.get(data["event_type"])

        accepted, reason = process_event(
            data["user_message_id"], event_type, data["nack_reason"], data["timestamp"]
        )

        return Response(
            {"accepted": accepted, "reason": reason}, status=200 if accepted else 400
        )
1148462
@POST
  @Path("{id}/account/confirm")
  @PermitAll
  public Response confirmAccount(@PathParam("id") Long userId, AccountRequest request) {
    checkNotNull(userId);
    checkNotNull(request.getToken());

    boolean isSuccess = userService.confirmAccountUsingToken(userId, request.getToken());
    return isSuccess ? Response.noContent().build() : Response.status(Response.Status.BAD_REQUEST).build();
  }
655310
def event_confirmation(self, date, time, pid, commerce_id, transaction_id, request_ip, order_id):
        '''
        '''
        raise NotImplementedError("Logging Handler must implement event_confirmation")
1347422
def confirm(text='', title='', buttons=['OK', 'Cancel']):
    """"""
    retVal = messageBoxFunc(0, text, title, MB_OKCANCEL | MB_ICONQUESTION | MB_SETFOREGROUND | MB_TOPMOST)
    if retVal == 1 or len(buttons) == 1:
        return buttons[0]
    elif retVal == 2:
        return buttons[1]
    else:
        assert False, 'Unexpected return value from MessageBox: %s' % (retVal)
1235425
public function confirmationAction(Request $request)
    {
        /** @var \Ekyna\Component\Sale\Order\OrderInterface $order */
        $order = $this->get('ekyna_order.order.repository')->findOneByKey(
            $request->attributes->get('orderKey')
        );

        if (null === $order) {
            throw new NotFoundHttpException('Order not found.');
        }

        if (null !== $user = $order->getUser()) {
            if ($user !== $this->getUser()) {
                throw new AccessDeniedHttpException('You are not allowed to view this resource.');
            }
        }

        if (null === $payment = $order->findPaymentById($request->attributes->get('paymentId'))) {
            throw new NotFoundHttpException('Payment not found.');
        }

        /** @var \Ekyna\Bundle\PaymentBundle\Model\MethodInterface $method */
        $method = $payment->getMethod();
        $message = $method->getMessageByState($payment->getState());
        if (null === $message || 0 == strlen($message->getFlash())) {
            $message = null;
        }

        return $this->render('EkynaCartBundle:Cart:confirmation.html.twig', [
            'order'   => $order,
            'payment' => $payment,
            'message' => $message,
        ]);
    }
751641
def post_result_data(self, client, check, output, status):
        
        data = {
            'source': client,
            'name': check,
            'output': output,
            'status': status,
        }
        self._request('POST', '/results', data=json.dumps(data))
        return True
1006706
def _put(self, url, data={}):
        """"""
        r = requests.put(self._api_prefix + url,
            data=json.dumps(data),
            headers=self.headers,
            auth=self.auth,
            allow_redirects=False,
        )
        return self._action(r)
714656
def send_request(url, method, data, 
	args, params, headers, cookies, timeout, is_json, verify_cert):
	
	## Parse url args
	for p in args:
		url = url.replace(':' + p, str(args[p]))

	try:
		if data:
			if is_json:
				headers['Content-Type'] = 'application/json'
				data = json.dumps(data)

			request = requests.Request(
				method.upper(), url, data=data, params=params, 
				headers=headers, cookies=cookies
			)
		else:
			request = requests.Request(
				method.upper(), url, params=params, headers=headers, 
				cookies=cookies
			)

		## Prepare and send HTTP request.
		session = requests.Session()
		session.verify = verify_cert
		r = session.send(request.prepare(), timeout=timeout)
		session.close()

	except requests.exceptions.Timeout:
		return {
			'data': {}, 
			'cookies': CookieJar(),
			'content_type': '', 
			'status': 0, 
			'is_json': False,
			'timeout': True
		}

	try:
		content_type = r.headers.get('Content-Type', 'application/json')
		response = r.json()
		isjson = True
		
	except json.decoder.JSONDecodeError:
		content_type = r.headers.get('Content-Type', 'text/html')
		response = r.text
		isjson = False

	return {
		'data': response,
		'cookies': r.cookies,
		'content_type': content_type, 
		'status': r.status_code,
		'is_json': isjson,
		'timeout': False
	}
558697
def confirmation(self, apdu):
        """"""
        if _debug: ClientSSM._debug("confirmation %r", apdu)

        if self.state == SEGMENTED_REQUEST:
            self.segmented_request(apdu)
        elif self.state == AWAIT_CONFIRMATION:
            self.await_confirmation(apdu)
        elif self.state == SEGMENTED_CONFIRMATION:
            self.segmented_confirmation(apdu)
        else:
            raise RuntimeError("invalid state")
1151746
def send(self, request):
        ''''''
        return self.session.send(request(self.url, self.auth))
1316133
def send_request(self, method, url, headers=None,
                     data=None, is_retry=False):
        """"""
        if not self._token:
            self.login()

        if not headers:
            headers = {}

        headers['Authorization'] = 'Bearer ' + self._oauth_token
        headers['ABODE-API-KEY'] = self._token

        try:
            response = getattr(self._session, method)(
                url, headers=headers, json=data)

            if response and response.status_code < 400:
                return response
        except RequestException:
            _LOGGER.info("Abode connection reset...")

        if not is_retry:
            # Delete our current token and try again -- will force a login
            # attempt.
            self._token = None

            return self.send_request(method, url, headers, data, True)

        raise AbodeException((ERROR.REQUEST))
1034379
def confirmation(self, pdu):
        """"""
        if _debug: NetworkAdapter._debug("confirmation %r (net=%r)", pdu, self.adapterNet)

        npdu = NPDU(user_data=pdu.pduUserData)
        npdu.decode(pdu)
        self.adapterSAP.process_npdu(self, npdu)
195518
function send(data) {
                verifyState(this);

                if (!/^(get|head)$/i.test(this.method)) {
                    var contentType = getHeader(this.requestHeaders, "Content-Type");
                    if (this.requestHeaders[contentType]) {
                        var value = this.requestHeaders[contentType].split(";");
                        this.requestHeaders[contentType] = value[0] + ";charset=utf-8";
                    } else if (!(data instanceof FormData)) {
                        this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";
                    }

                    this.requestBody = data;
                }

                this.errorFlag = false;
                this.sendFlag = this.async;
                this.readyStateChange(FakeXMLHttpRequest.OPENED);

                if (typeof this.onSend == "function") {
                    this.onSend(this);
                }

                this.dispatchEvent(new sinon.Event("loadstart", false, false, this));
            }
133917
def send(self):
        
        web.ctx.status = _convert_http_status(self.status_code)
        return _api_convert_output(self.return_value)
300966
function success(response, body) {
  var content = _.assign(body || {}, {success: true});
  send(response, content, StatusCode.ok);
}