first commit

lib/Model/Transform/BaseResponseUnMarshaller.php

@@ -0,0 +1,150 @@
+<?php
+
+namespace Yeepay\Yop\Sdk\Model\Transform;
+
+use Psr\Log\LoggerInterface;
+use Yeepay\Yop\Sdk\Exception\YopClientException;
+use Yeepay\Yop\Sdk\Exception\YopServiceException;
+use Yeepay\Yop\Sdk\Http\ContentType;
+use Yeepay\Yop\Sdk\Http\Headers;
+use Yeepay\Yop\Sdk\Http\HttpStatus;
+use Yeepay\Yop\Sdk\Http\YopHttpResponse;
+use Yeepay\Yop\Sdk\Log\LogFactory;
+use Yeepay\Yop\Sdk\Model\BaseResponse;
+use Yeepay\Yop\Sdk\Model\YopResponseMetadata;
+use Yeepay\Yop\Sdk\Utils\ObjectSerializer;
+use Yeepay\Yop\Sdk\Utils\YopConstants;
+
+abstract class BaseResponseUnMarshaller implements ResponseUnMarshaller
+{
+
+    /**
+     * @var LoggerInterface
+     */
+    private static $logger;
+
+    public static function __init()
+    {
+        self::$logger = LogFactory::getLogger(self::class);
+    }
+
+    public function unmarshal(YopHttpResponse $yopHttpResponse, ResponseUnMarshalParams $params)
+    {
+        $response = $this->getResponseInstance();
+        $this->handleResponseMetaData($yopHttpResponse, $response->getMetadata());
+        $this->checkSignature($yopHttpResponse, $response->getMetadata()->getYopSign(), $params);
+        $this->handleContent($yopHttpResponse, $response->getMetadata()->getContentType(), $response, $params);
+
+        return $response;
+    }
+
+    /**
+     * @return BaseResponse
+     */
+    protected abstract function getResponseInstance();
+
+    /**
+     * @param  YopHttpResponse  $yopHttpResponse
+     * @param  YopResponseMetadata  $responseMetadata
+     */
+    public function handleResponseMetaData($yopHttpResponse, YopResponseMetadata $responseMetadata)
+    {
+        $responseMetadata->setYopRequestId($yopHttpResponse->getHeader(Headers::YOP_REQUEST_ID));
+        $responseMetadata->setYopContentSha256($yopHttpResponse->getHeader(Headers::YOP_CONTENT_SHA256));
+        $responseMetadata->setYopSign($yopHttpResponse->getHeader(Headers::YOP_SIGN));
+        $responseMetadata->setYopVia($yopHttpResponse->getHeader(Headers::YOP_VIA));
+        $responseMetadata->setContentDisposition($yopHttpResponse->getHeader(Headers::CONTENT_DISPOSITION));
+        $responseMetadata->setContentEncoding($yopHttpResponse->getHeader(Headers::CONTENT_ENCODING));
+        $responseMetadata->setContentLength($yopHttpResponse->getHeaderAsLong(Headers::CONTENT_LENGTH));
+        $responseMetadata->setContentType($yopHttpResponse->getHeader(Headers::CONTENT_TYPE));
+        $responseMetadata->setDate($yopHttpResponse->getHeaderAsRFC822Date(Headers::DATE));
+        $responseMetadata->setTransferEncoding($yopHttpResponse->getHeader(Headers::TRANSFER_ENCODING));
+
+        $etag = $yopHttpResponse->getHeader(Headers::ETAG);
+        if (isset($etag)) {
+            //TODO 此处对比java版有所简略
+            $responseMetadata->setEtag($etag);
+        }
+        $responseMetadata->setExpires($yopHttpResponse->getHeaderAsRFC822Date(Headers::EXPIRES));
+        $responseMetadata->setLastModified($yopHttpResponse->getHeaderAsRFC822Date(Headers::LAST_MODIFIED));
+        $responseMetadata->setServer($yopHttpResponse->getHeader(Headers::SERVER));
+        if ($responseMetadata->getYopVia() == YopConstants::DEFAULT_SANDBOX_VIA) {
+            self::$logger->info('response from sandbox-gateway');
+        }
+
+    }
+
+    private function checkSignature(YopHttpResponse $yopHttpResponse, $signature, ResponseUnMarshalParams $params)
+    {
+        if (isset($signature)) {
+            $params->getSigner()
+                   ->checkSignature($yopHttpResponse, $signature, $params->getPublicKey(), $params->getSignOptions());
+        }
+    }
+
+    /**
+     * @param  YopHttpResponse  $yopHttpResponse
+     * @param $contentType
+     * @param  BaseResponse  $response
+     * @param  ResponseUnMarshalParams  $params
+     * @throws YopClientException
+     */
+    protected function handleContent(
+        YopHttpResponse $yopHttpResponse,
+        $contentType,
+        BaseResponse $response,
+        ResponseUnMarshalParams $params
+    ) {
+        $content = $yopHttpResponse->readContent();
+        if ($params->isNeedDecrypt() && $contentType == ContentType::APPLICATION_JSON) {
+            $content = $params->getEncryptor()->decrypt($content);
+        }
+        $statusCode = $yopHttpResponse->getStatusCode();
+        if ($statusCode / 100 == HttpStatus::SC_OK / 100) {
+            if ($statusCode != HttpStatus::SC_NO_CONTENT) {
+                $data = json_decode($content);
+                $response->setResult(ObjectSerializer::deserialize($data->{'result'}, $response->getResultClass()));
+            }
+        } elseif ($statusCode >= HttpStatus::SC_INTERNAL_SERVER_ERROR && $statusCode != HttpStatus::SC_BAD_GATEWAY) {
+            $this->handleErrorResponse($content, $response->getMetadata(), $yopHttpResponse);
+        } else {
+            throw new YopClientException("Unexpected http statusCode:".$statusCode);
+        }
+    }
+
+    /**
+     * @param $content
+     * @param  YopResponseMetadata  $responseMetadata
+     * @param  YopHttpResponse  $yopHttpResponse
+     * @throws YopServiceException
+     */
+    protected function handleErrorResponse(
+        $content,
+        YopResponseMetadata $responseMetadata,
+        YopHttpResponse $yopHttpResponse
+    ) {
+        $yopServiceException = null;
+        if (!empty($content)) {
+            try {
+                $data = json_decode($content, true);
+                dd($data);
+                $yopServiceException = new YopServiceException($data['message'], $data['code']);
+                $yopServiceException->setRequestId($data['requestId']);
+                $yopServiceException->setSubErrorCode($data['subCode']);
+                $yopServiceException->setSubErrorMessage($data['subMessage']);
+            } catch (\Exception $e) {
+                self::$logger->error("unable to parse error response, content".$content);
+            }
+        }
+        if (!isset($yopServiceException)) {
+            $yopServiceException = new YopServiceException($yopHttpResponse->getStatusText());
+            $yopServiceException->setRequestId($responseMetadata->getYopRequestId());
+        }
+        $yopServiceException->setStatusCode($yopHttpResponse->getStatusCode());
+        $yopServiceException->setErrorType(YopServiceException::ERROR_TYPE_SERVICE);
+        throw $yopServiceException;
+    }
+
+}
+
+BaseResponseUnMarshaller::__init();

lib/Model/Transform/RequestMarshaller.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Yeepay\Yop\Sdk\Model\Transform;
+
+use Yeepay\Yop\Sdk\Internal\Request;
+use Yeepay\Yop\Sdk\Model\BaseRequest;
+
+interface RequestMarshaller
+{
+
+    /**
+     * @param  BaseRequest  $request
+     * @return Request
+     */
+    public function marshal($request);
+
+}

lib/Model/Transform/ResponseUnMarshalParams.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace Yeepay\Yop\Sdk\Model\Transform;
+
+use Yeepay\Yop\Sdk\Auth\Encryptor;
+use Yeepay\Yop\Sdk\Auth\Signer;
+use Yeepay\Yop\Sdk\Auth\SignOptions;
+
+class ResponseUnMarshalParams
+{
+
+    /**
+     * @var resource
+     */
+    private $publicKey;
+
+    /**
+     * @var Signer
+     */
+    private $signer;
+
+    /**
+     * @var SignOptions
+     */
+    private $signOptions;
+
+    /**
+     * @var bool
+     */
+    private $needDecrypt;
+
+    /**
+     * @var Encryptor
+     */
+    private $encryptor;
+
+    /**
+     * @return resource
+     */
+    public function getPublicKey()
+    {
+        return $this->publicKey;
+    }
+
+    /**
+     * @param  resource  $publicKey
+     * @return ResponseUnMarshalParams
+     */
+    public function setPublicKey($publicKey)
+    {
+        $this->publicKey = $publicKey;
+
+        return $this;
+    }
+
+    /**
+     * @return Signer
+     */
+    public function getSigner()
+    {
+        return $this->signer;
+    }
+
+    /**
+     * @param  Signer  $signer
+     * @return ResponseUnMarshalParams
+     */
+    public function setSigner($signer)
+    {
+        $this->signer = $signer;
+
+        return $this;
+    }
+
+    /**
+     * @return SignOptions
+     */
+    public function getSignOptions()
+    {
+        return $this->signOptions;
+    }
+
+    /**
+     * @param  SignOptions  $signOptions
+     * @return ResponseUnMarshalParams
+     */
+    public function setSignOptions($signOptions)
+    {
+        $this->signOptions = $signOptions;
+
+        return $this;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isNeedDecrypt()
+    {
+        return $this->needDecrypt;
+    }
+
+    /**
+     * @param  bool  $needDecrypt
+     * @return ResponseUnMarshalParams
+     */
+    public function setNeedDecrypt($needDecrypt)
+    {
+        $this->needDecrypt = $needDecrypt;
+
+        return $this;
+    }
+
+    /**
+     * @return Encryptor
+     */
+    public function getEncryptor()
+    {
+        return $this->encryptor;
+    }
+
+    /**
+     * @param  Encryptor  $encryptor
+     * @return ResponseUnMarshalParams
+     */
+    public function setEncryptor($encryptor)
+    {
+        $this->encryptor = $encryptor;
+
+        return $this;
+    }
+
+}

lib/Model/Transform/ResponseUnMarshaller.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Yeepay\Yop\Sdk\Model\Transform;
+
+use Yeepay\Yop\Sdk\Http\YopHttpResponse;
+
+interface ResponseUnMarshaller
+{
+
+    /**
+     * @param $yopHttpResponse YopHttpResponse
+     * @param  ResponseUnMarshalParams  $params
+     * @return mixed
+     */
+    public function unmarshal(YopHttpResponse $yopHttpResponse, ResponseUnMarshalParams $params);
+
+}

lib/Model/Transform/YosDownloadResponseUnMarshaller.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Yeepay\Yop\Sdk\Model\Transform;
+
+use Yeepay\Yop\Sdk\Exception\YopClientException;
+use Yeepay\Yop\Sdk\Http\ContentType;
+use Yeepay\Yop\Sdk\Http\HttpStatus;
+use Yeepay\Yop\Sdk\Http\YopHttpResponse;
+use Yeepay\Yop\Sdk\Model\BaseResponse;
+use Yeepay\Yop\Sdk\Model\YosDownloadResponse;
+
+class YosDownloadResponseUnMarshaller extends BaseResponseUnMarshaller
+{
+
+    /**
+     * @return YosDownloadResponse
+     */
+    protected function getResponseInstance()
+    {
+        return new YosDownloadResponse();
+    }
+
+    protected function handleContent(
+        YopHttpResponse $yopHttpResponse,
+        $contentType,
+        BaseResponse $response,
+        ResponseUnMarshalParams $params
+    ) {
+        $statusCode = $yopHttpResponse->getStatusCode();
+        if ($statusCode / 100 == HttpStatus::SC_OK / 100 && $statusCode != HttpStatus::SC_NO_CONTENT) {
+            $response->setResult($yopHttpResponse->getContent());
+        } elseif ($statusCode >= HttpStatus::SC_INTERNAL_SERVER_ERROR && $statusCode != HttpStatus::SC_BAD_GATEWAY) {
+            $content = $yopHttpResponse->readContent();
+            if ($params->isNeedDecrypt() && $contentType == ContentType::APPLICATION_JSON) {
+                $content = $params->getEncryptor()->decrypt($content);
+            }
+            $this->handleErrorResponse($content, $response->getMetadata(), $yopHttpResponse);
+        } else {
+            throw new YopClientException("Unexpected http statusCode:".$statusCode);
+        }
+    }
+
+}