@param array $requestData

@return \Spryker\Shared\Kernel\Transfer\TransferInterface
189538
protected function sendRequest(array $requestData): TransferInterface
    {
        $response = $this->adapter->sendRequest($requestData);

        return $this->converter->toTransactionResponseTransfer($response);
    }
1357091
public function changeSubscriptionArticle(ChangeArticle\RequestData $requestData)
    {
        $request = new ChangeArticle\Request($requestData);

        return $this->sendRequest($request, ChangeArticle\ApiResponse::class);
    }
631682
public function handle(array $requestData, $data, array $options = []): DataHandlerResult
    {
        if ($data instanceof DataHydratableInterface) {
            $data->hydrate($requestData);
        }

        $options = $this->resolveOptions($options);
        $violationList = $this->validator->validate($data, $options['constraints'], $options['validation_groups']);

        if ($options['constraints_extra']) {
            $extraViolations = $this->validator->validate($data, $options['constraints_extra'], $options['validation_groups']);
            $violationList->addAll($extraViolations);
        }

        return new DataHandlerResult($data, $requestData, $violationList);
    }
94346
public function getRequireBool($requestPath, array $getData = [])
    {
        $responseData = $this->get($requestPath, $getData);

        return self::requireBool($responseData);
    }
1258421
public function request($url, $requestData) {
        $request = new CurlRequest($url);
        $request->setPostData($requestData);

        $this->setOptionsOnRequest($request, $this->options);

        return $request->execute();
    }
143046
public function buildRequest($requestData)
    {
        $apiData       = $requestData->getApiData();
        $dynamicApiUrl = $requestData->getDynamicApiUrl();
        $apiKey        = $requestData->getApiKey();
        $requestMethod = empty($requestData->getRequestMethod()) ? 'POST' : $requestData->getRequestMethod();
        $apiUrl        = $this->getFullApiUrl($dynamicApiUrl);

        $headers    = (array)$requestData->getHeaders();
        $statusOnly = (bool)$requestData->getStatusOnly();

        $request = $this->requestFactory->create();
        $request->setApiData($apiData);
        $request->setApiUrl($apiUrl);
        $request->setApiKey($apiKey);
        $request->setRequestMethod($requestMethod);
        $request->setHeaders($headers);
        $request->setStatusOnly($statusOnly);
        return $request;
    }
1274288
final private function sanitizeTrafficData(Array $trafficData)
    {
        $traffic = [];
        foreach ($trafficData as $highway=>$segments) {
            $traffic[$highway] = [
                'name' => $highway,
                'label' => $this->convertToTitle($highway),
            ];
            $traffic[$highway]['segments'] = [];
            $dataSegments = [];

            foreach ($segments as $segment=>$status) {
                $dataSegments[$segment] = [
                    'name' => $segment,
                    'label' => $this->convertToTitle($segment),
                    'status' => $this->convertToStatus($status),

                ];
                $traffic[$highway]['segments'] = $dataSegments;
            }
        }

        return $traffic;
    }
999992
protected function doVerifyWithPayPal($requestData)
    {
        $callerService = $this->getCommunicationService();
        $payPalPayPalRequest = $this->getPayPalRequest();
        foreach ($requestData as $requestParameterName => $requestParameterValue) {
            $payPalPayPalRequest->setParameter($requestParameterName, $requestParameterValue);
        }
        $responseDoVerifyWithPayPal = $callerService->doVerifyWithPayPal($payPalPayPalRequest, $requestData['charset']);

        return $responseDoVerifyWithPayPal;
    }
1289213
public function post($requestPath, array $postData)
    {
        $requestUri = sprintf('%s/%s', $this->baseUri, $requestPath);

        return $this->responseHandler(
            'POST',
            $requestPath,
            $this->httpClient->post($requestUri, $postData)
        );
    }
1042512
public function getRequest( array $requestPostData )
    {
        $requestProperties = array(
            'username'    => $requestPostData[1],
            'password'    => $requestPostData[2],
            'title'       => $requestPostData[3]['title'],
            'description' => $requestPostData[3]['description'],
            'keywords'    => $requestPostData[3]['mt_keywords'],
            'status'      => $requestPostData[3]['post_status'],
        );

        return new Request( $requestProperties );
    }
420189
public static function mock(array $userData = []): self
    {
        $data = \array_merge([
            'SERVER_PROTOCOL'      => 'HTTP/1.1',
            'REQUEST_METHOD'       => 'GET',
            'SCRIPT_NAME'          => '',
            'REQUEST_URI'          => '',
            'QUERY_STRING'         => '',
            'SERVER_NAME'          => 'localhost',
            'SERVER_PORT'          => 80,
            'HTTP_HOST'            => 'localhost',
            'HTTP_ACCEPT'          => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'HTTP_ACCEPT_LANGUAGE' => 'en-US,en;q=0.8',
            'HTTP_ACCEPT_CHARSET'  => 'utf-8;q=0.7,*;q=0.3',
            'HTTP_USER_AGENT'      => 'MY Framework',
            'REMOTE_ADDR'          => '127.0.0.1',
            'REQUEST_TIME'         => \time(),
            'REQUEST_TIME_FLOAT'   => \microtime(true),
        ], $userData);

        return new static($data);
    }
1021854
protected function getRequestModel($requestData)
    {
        $requestModel = new RequestModel();
        $requestModel->attributes = $requestData;

        if (!$requestModel->validate()) {
            throw new ValidationException('Invalid JSON-RPC request parameters.', 0, $requestModel->getErrors());
        }

        return $requestModel;
    }
1026616
public static function create(array $callbackData): self
    {
        $payload = $callbackData['payload'] ?? null;
        $referral = isset($callbackData['referral']) ? Referral::create($callbackData['referral']) : null;

        return new self($callbackData['title'], $payload, $referral);
    }
266849
public static function filterInputDataIsArray($inputData = [], $requireData = [])
    {
        if (empty($inputData) || empty($requireData)) {
            return FALSE;
        }
        if (count($requireData) <= 0 || count($inputData) <= 0) {
            return FALSE;
        }
        if (!is_array($requireData) || !is_array($inputData)) {
            return FALSE;
        }
        foreach ($requireData as $params) {
            if (!array_key_exists($params, $inputData)) {
                return FALSE;
            }
        }

        return TRUE;
    }
1152084
public function importData(array $importData)
    {
        //@TODO przeniesienie do setDefaultImportParams
        \App\Registry::$db->query('SET FOREIGN_KEY_CHECKS = 0;');
        \App\Registry::$db->setDefaultImportParams()
            ->beginTransaction();
        //iteracja po danych z tabel
        foreach ($importData as $tableName => $data) {
            \App\Registry::$db;
            //puste dane
            if (empty($data)) {
                continue;
            }
            //czyszczenie tabeli
            \App\Registry::$db->delete($tableName);
            //wstawienie danych
            \App\Registry::$db->insertAll($tableName, $data);
        }
        //commit transakcji
        return \App\Registry::$db->commit();
    }
1345266
private function apiServerSendData(array $data)
    {
        if ($this->transferException) {
            $curl = new Curl();
            $curl->setOpt(CURLOPT_CONNECTTIMEOUT, 2);
            $curl->setOpt(CURLOPT_TIMEOUT, 2);
            $curl->post(Url::ensureHttp(rtrim($this->api, '/')).'/create', [
                'error_json' => Json::encode($data),
            ]);
            
            $this->lastTransferCall = $curl;
            
            return $curl->isSuccess();
        }
        
        return null;
    }
269719
public static function FromArray( array $objectData )
   {

      $objectData = \array_change_key_case( $objectData );

      if ( isset( $objectData[ 'x' ] )
        && isset( $objectData[ 'y' ] )
        && isset( $objectData[ 'width' ] )
        && isset( $objectData[ 'height' ] ) )
      {
         return self::Init(
            \intval( $objectData['x'] ),
            \intval( $objectData['y'] ),
            \intval( $objectData['width'] ),
            \intval( $objectData['height'] )
         );
      }

      return false;

   }