Get the verification.

@param CardPayments\Verification $verify
@return CardPayments\Verification
@throws PaysafeException
509487
public function getVerification(CardPayments\Verification $verify)
    {
        $verify->setRequiredFields(array('id'));
        $verify->checkRequiredFields();

        $request = new Request(array(
             'method' => Request::GET,
             'uri' => $this->prepareURI("/verifications/" . $verify->id)
        ));

        $response = $this->client->processRequest($request);
        return new CardPayments\Verification($response);
    }
1250517
public function verify()
	{
		if (!$this->request->has('transaction_id') && !$this->request->has('iN'))
			throw new InvalidRequestException;
		if ($this->request->has('transaction_id')) {
			$id = $this->request->get('transaction_id');
		}else {
			$id = $this->request->get('iN');
		}

		$transaction = $this->getTable()->whereId($id)->first();

		if (!$transaction)
			throw new NotFoundTransactionException;

		if (in_array($transaction->status, [Enum::TRANSACTION_SUCCEED, Enum::TRANSACTION_FAILED]))
			throw new RetryException;

		$this->make($transaction->port);

		return $this->port->verify($transaction);
	}
1247454
public function getPaymentId()
    {
        if (!$this->_sPaymentId) {
            $this->_sPaymentId = \OxidEsales\Eshop\Core\Registry::getSession()->getVariable('paymentid');
        }

        return $this->_sPaymentId;
    }
410261
public function verify(SignedJwt $jwt, VerificationContext $verificationContext, array &$errors) : bool
    {
        $verifiers = [
            new SignatureVerifier($verificationContext->getSigner()),
            new AudienceVerifier($verificationContext->getAudience()),
            new ExpirationVerifier(),
            new NotBeforeVerifier(),
            new IssuerVerifier($verificationContext->getIssuer()),
            new SubjectVerifier($verificationContext->getSubject())
        ];
        $isVerified = true;

        /** @var IVerifier $verifier */
        foreach ($verifiers as $verifier) {
            $error = '';

            if (!$verifier->verify($jwt, $error)) {
                $isVerified = false;
                $errors[] = $error;
            }
        }

        return $isVerified;
    }
938163
public function validateSmsCode($paymentID, $smsCode)
    {
        $obj = new StdClass();

        // Must be in specific order for checksum ---------        
        $obj->MerchantID = $this->getMerchantID();
        $obj->Timestamp = $this->getTimeStamp();
        $obj->PaymentID = $paymentID;
        $obj->SmsCode = $smsCode;

        $obj->Checksum = $this->generateChecksum($obj, $this->getSecretCode());

        $result = $this->client->ValidateSmsCode(array('request' => $obj));
        $result = $result->ValidateSmsCodeResult;

        /* store the checksum momentarily */
        $checksum = $result->Checksum;

        /* Replace the checksum in the data with secretCode to generate a new checksum */
        $result->Checksum = $this->getSecretCode();

        /* Verify response data */
        if ($checksum != $this->generateChecksum($result))
            throw new Exception("Data could not be verified");

        return $result->Success;
    }
1102198
public function verify($customerId, $bankAccountId, array $amounts, $verificationMethod = null)
    {
        return $this->_post("customers/{$customerId}/sources/{$bankAccountId}/verify", [
            'amounts' => $amounts, 'verification_method' => $verificationMethod,
        ]);
    }
1152745
protected function validateVerification(array $credentials)
    {
        if (is_null($user = $this->getUser($credentials))) {
            return Contracts\VerificationBroker::INVALID_USER;
        }

        if (!$this->tokens->exists($user, $credentials['token'])) {
            return Contracts\VerificationBroker::INVALID_TOKEN;
        }

        return $user;
    }
638536
public function verifyWithExtra($inputs)
    {
        $result = $this->restCall('PaymentVerificationWithExtra.json', $inputs);

        if ($result['Status'] == 100) {
            return [
                'Status'      => 'success',
                'RefID'       => $result['RefID'],
                'ExtraDetail' => $result['ExtraDetail'],
            ];
        } elseif ($result['Status'] == 101) {
            return [
                'Status'      => 'verified_before',
                'RefID'       => $result['RefID'],
                'ExtraDetail' => $result['ExtraDetail'],
            ];
        } else {
            return [
                'Status'    => 'error',
                'error'     => !empty($result['Status']) ? $result['Status'] : null,
                'errorInfo' => !empty($result['errors']) ? $result['errors'] : null,
            ];
        }
    }
873182
protected function verifyPayment()
	{
		try {
			$soap = new SoapClient($this->serverUrl);

			$result = $soap->CheckRequestStatusResult(
				$this->transactionId(),
				$this->config->get('gateway.sadad.merchant'),
				$this->config->get('gateway.sadad.terminalId'),
				$this->config->get('gateway.sadad.transactionKey'),
				$this->refId(),
				$this->amount
			);

		} catch (\SoapFault $e) {
			$this->transactionFailed();
			$this->newLog('SoapFault', $e->getMessage());
			throw $e;
		}

		if (empty($result) || !isset($result->AppStatusCode))
			throw new SadadException('در دریافت اطلاعات از بانک خطایی رخ داده است.');

		$statusResult = strval($result->AppStatusCode);
		$appStatus = strtolower($result->AppStatusDescription);

		$message = $this->getMessage($statusResult, $appStatus);

		$this->newLog($statusResult, $message['fa']);

		if ($statusResult != 0 || $appStatus !== 'commit') {
			$this->transactionFailed();
			throw new SadadException($message['fa'], $statusResult);
		}
		$this->trackingCode = $result->TraceNo;
		$this->cardNumber = $result->CustomerCardNumber;
		$this->transactionSucceed();
	}
1175518
protected function proxy() {
        if (!$this->context) {
            $this->context = new VerificationContext(
                $this->version,
                $this->solution['serviceSid'],
                $this->solution['sid']
            );
        }

        return $this->context;
    }
1070808
public static function verify($original, $hash, $verify = false)
    {
        self::self($verify);

        return self::$driver->verify($original, $hash);
    }
283681
public function getFor(Payment $payment, $captureId, array $parameters = [])
    {
        return $this->getForId($payment->id, $captureId, $parameters);
    }
142420
public function verifyReceipt($receipt) {
        $Request = $this->getRequest($this->getEndpointUrl());
        $Request->addPostField('receipt-data', $receipt)
            ->addPostField('password', $this->getPassword());
        $data = $Request->send();
        try {
            return ResponsePayload::initializeByString($data);
        } catch (InvalidArgumentException $Ex) {
            try {
                return RenewableStatus::initializeByString($data);
            } catch (InvalidArgumentException $ex) {
                return Status::initializeByString($data);
            }
        }
    }
465807
public function check($file, $verify = null)
	{
		if (is_string($verify))
		{
			$verify = "lead" . strtoupper($verify);
		}

		$detectives = [];
		foreach ($this->detectives as $detectiveClass)
		{
			if ($detectiveClass::on())
			{
				$detectives[] = $detectiveClass;
			}
		}

		$case = null;

		foreach ($detectives as $detectiveClass)
		{
			$detective = new $detectiveClass();
			$case      = $detective->check($file, $verify);

			if ($case)
			{
				return $detective;
			}
		}

		return false;
	}
964951
public function getCard($cardID)
    {
        $tokenContext = new TokenContext("", 'get');
        $token = $this->accessTokenProvider->getToken($tokenContext);

        $responseModel = $this->cardClient->getCard($cardID, (string)$token);
        if ($responseModel instanceof ErrorResponseModel) {
            throw new CardClientException(
                "error response from card service", $responseModel->getCode(), $responseModel->getMessage()
            );
        }

        $card = $this->parseRawCard($responseModel->getRawSignedModel(), $responseModel->isOutdated());

        if (!$this->cardVerifier->verifyCard($card)) {
            throw new CardVerificationException('Validation errors have been detected');
        }

        return $card;
    }
338662
public function verify($data_to_verify, $base64_signature)
    {
        $calculated_signature = base64_encode(hash_hmac('sha256', $data_to_verify, $this->getSharedKey(), true));
        $verify               = hash_equals($calculated_signature, $base64_signature);

        return $verify;
    }
922523
public function verify($content = null, $refund = false): Collection
    {
        $request = Request::createFromGlobals();

        $data = $request->request->count() > 0 ? $request->request->all() : $request->query->all();

        $data = Support::encoding($data, 'utf-8', $data['charset'] ?? 'gb2312');

        Log::debug('Receive Alipay Request:', $data);

        if (Support::verifySign($data, $this->config->get('ali_public_key'))) {
            return new Collection($data);
        }

        Log::warning('Alipay Sign Verify FAILED', $data);

        throw new InvalidSignException('Alipay Sign Verify FAILED', $data);
    }