Initial commit

modules/colissimo/lib/Response/AbstractColissimoResponse.php

@@ -0,0 +1,13 @@
+<?php
+
+/**
+ * Class AbstractColissimoResponse
+ */
+class AbstractColissimoResponse
+{
+    /** @var array $messages */
+    public $messages;
+
+    /** @var array $response */
+    public $response;
+}

modules/colissimo/lib/Response/ColissimoCheckGenerateLabelResponse.php

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * Class ColissimoCheckGenerateLabelResponse
+ */
+class ColissimoCheckGenerateLabelResponse extends AbstractColissimoResponse implements ColissimoReturnedResponseInterface
+{
+    /**
+     * @param mixed $responseHeader
+     * @param mixed $responseBody
+     * @return mixed
+     * @throws Exception
+     */
+    public static function buildFromResponse($responseHeader, $responseBody)
+    {
+        $checkGenerateLabelResponse = new self();
+        $responseArray = json_decode($responseBody, true);
+        if (!empty($responseArray)) {
+            $checkGenerateLabelResponse->messages = $responseArray['messages'];
+            $checkGenerateLabelResponse->response = $responseArray;
+        }
+
+        return $checkGenerateLabelResponse;
+    }
+}

modules/colissimo/lib/Response/ColissimoGenerateBordereauResponse.php

@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * Class ColissimoGenerateBordereauResponse
+ */
+class ColissimoGenerateBordereauResponse extends AbstractColissimoResponse implements ColissimoReturnedResponseInterface
+{
+    /** @var string $bordereau */
+    public $bordereau;
+
+    /** @var array $bordereauHeader */
+    public $bordereauHeader;
+
+    /**
+     * @param mixed $responseHeader
+     * @param mixed $responseBody
+     * @return mixed
+     * @throws Exception
+     */
+    public static function buildFromResponse($responseHeader, $responseBody)
+    {
+        $soapResponseParser = new ColissimoResponseParser();
+        try {
+            $parsedResponse = $soapResponseParser->parseBody($responseBody);
+            $parsedHeaders = $soapResponseParser->parseHeaders($responseHeader);
+        } catch (Exception $e) {
+            throw new Exception($e->getMessage());
+        }
+        $generateBordereauResponse = new self();
+        $contentType = $soapResponseParser->parseContentType($parsedHeaders);
+        if (isset($parsedResponse[$contentType])) {
+            $xml = new SimpleXMLElement($parsedResponse[$contentType]);
+            $xml->registerXPathNamespace('ns2', 'http://sls.ws.coliposte.fr');
+            $xml->registerXPathNamespace('xop', 'http://www.w3.org/2004/08/xop/include');
+            $bordereau = $xml->xpath('soap:Body/ns2:generateBordereauByParcelsNumbersResponse/return/bordereau/bordereauDataHandler/xop:Include');
+            if (!empty($bordereau)) {
+                $cidBordereau = substr($bordereau[0]->attributes()->href->__toString(), 4);
+                if (isset($parsedResponse['<'.$cidBordereau.'>'])) {
+                    $generateBordereauResponse->bordereau = base64_encode($parsedResponse['<'.$cidBordereau.'>']);
+                }
+            }
+            $bordereauHeader = $xml->xpath('soap:Body/ns2:generateBordereauByParcelsNumbersResponse/return/bordereau/bordereauHeader');
+            if (!empty($bordereauHeader)) {
+                $generateBordereauResponse->bordereauHeader = json_decode(json_encode($bordereauHeader[0]), true);
+                $generateBordereauResponse->response['bordereauHeader'] = $generateBordereauResponse->bordereauHeader;
+            }
+            $messages = $xml->xpath('soap:Body/ns2:generateBordereauByParcelsNumbersResponse/return/messages');
+            $generateBordereauResponse->messages = json_decode(json_encode($messages), true);
+            $generateBordereauResponse->response['messages'] = $generateBordereauResponse->messages;
+        }
+
+        return $generateBordereauResponse;
+    }
+}

modules/colissimo/lib/Response/ColissimoGenerateLabelResponse.php

@@ -0,0 +1,48 @@
+<?php
+
+/**
+ * Class ColissimoGenerateLabelResponse
+ */
+class ColissimoGenerateLabelResponse extends AbstractColissimoResponse implements ColissimoReturnedResponseInterface
+{
+    /** @var string $label */
+    public $label;
+
+    /** @var string $cn23 */
+    public $cn23;
+
+    /** @var string $parcelNumber */
+    public $parcelNumber;
+
+    /**
+     * @param mixed $responseHeader
+     * @param mixed $responseBody
+     * @return mixed
+     * @throws Exception
+     */
+    public static function buildFromResponse($responseHeader, $responseBody)
+    {
+        $jsonResponseParser = new ColissimoResponseParser();
+        try {
+            $parsedResponse = $jsonResponseParser->parseBody($responseBody);
+        } catch (Exception $e) {
+            throw new Exception($e->getMessage());
+        }
+        $generateLabelResponse = new self();
+        if (isset($parsedResponse['<jsonInfos>'])) {
+            $generateLabelResponse->response = json_decode($parsedResponse['<jsonInfos>'], true);
+            $generateLabelResponse->messages = $generateLabelResponse->response['messages'];
+        }
+        if (isset($generateLabelResponse->response['labelV2Response']['parcelNumber'])) {
+            $generateLabelResponse->parcelNumber = $generateLabelResponse->response['labelV2Response']['parcelNumber'];
+        }
+        if (isset($parsedResponse['<label>'])) {
+            $generateLabelResponse->label = base64_encode($parsedResponse['<label>']);
+        }
+        if (isset($parsedResponse['<cn23>'])) {
+            $generateLabelResponse->cn23 = base64_encode($parsedResponse['<cn23>']);
+        }
+
+        return $generateLabelResponse;
+    }
+}

modules/colissimo/lib/Response/ColissimoMailboxDetailsResponse.php

@@ -0,0 +1,45 @@
+<?php
+
+/**
+ * Class ColissimoMailboxDetailsResponse
+ */
+class ColissimoMailboxDetailsResponse extends AbstractColissimoResponse implements ColissimoReturnedResponseInterface
+{
+    /** @var string $maxPickingHour */
+    public $maxPickingHour;
+
+    /** @var string $validityTime */
+    public $validityTime;
+
+    /** @var array $pickingDates */
+    public $pickingDates;
+
+    /**
+     * @param mixed $responseHeader
+     * @param mixed $responseBody
+     * @return mixed
+     * @throws Exception
+     */
+    public static function buildFromResponse($responseHeader, $responseBody)
+    {
+        $mailboxDetailsResponse = new self();
+        $responseArray = json_decode($responseBody, true);
+        if (!empty($responseArray)) {
+            $mailboxDetailsResponse->messages = $responseArray['messages'];
+            $mailboxDetailsResponse->response = $responseArray;
+            if (isset($responseArray['mailBoxPickingDateMaxHour'])) {
+                $mailboxDetailsResponse->maxPickingHour = $responseArray['mailBoxPickingDateMaxHour'];
+            }
+            if (isset($responseArray['validityTime'])) {
+                $mailboxDetailsResponse->validityTime = $responseArray['validityTime'];
+            }
+            if (isset($responseArray['mailBoxPickingDates'])) {
+                foreach ($responseArray['mailBoxPickingDates'] as $mailBoxPickingDate) {
+                    $mailboxDetailsResponse->pickingDates[] = $mailBoxPickingDate / 1000;
+                }
+            }
+        }
+
+        return $mailboxDetailsResponse;
+    }
+}

modules/colissimo/lib/Response/ColissimoPlanPickupResponse.php

@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * Class ColissimoPlanPickupResponse
+ */
+class ColissimoPlanPickupResponse extends AbstractColissimoResponse implements ColissimoReturnedResponseInterface
+{
+    /**
+     * @param mixed $responseHeader
+     * @param mixed $responseBody
+     * @return mixed
+     * @throws Exception
+     */
+    public static function buildFromResponse($responseHeader, $responseBody)
+    {
+        $planPickupResponse = new self();
+        $responseArray = json_decode($responseBody, true);
+        if (!empty($responseArray)) {
+            $planPickupResponse->messages = $responseArray['messages'];
+            $planPickupResponse->response = $responseArray;
+        }
+
+        return $planPickupResponse;
+    }
+}

modules/colissimo/lib/Response/ColissimoResponseParser.php

@@ -0,0 +1,149 @@
+<?php
+
+/**
+ * Class ColissimoResponseParser
+ */
+class ColissimoResponseParser
+{
+    /** Regex for separator */
+    const UUID = '/--uuid:/';
+
+    /** New line character in Response */
+    const NEW_LINE_CHAR = "\r\n";
+
+    /** @var string $uuid */
+    private $uuid;
+
+    /**
+     * @param string $rawHeaders
+     * @return array
+     */
+    public function parseHeaders($rawHeaders)
+    {
+        $headers = array();
+        $key = '';
+
+        foreach (explode("\n", $rawHeaders) as $i => $h) {
+            $h = explode(':', $h, 2);
+            if (isset($h[1])) {
+                if (!isset($headers[$h[0]])) {
+                    $headers[$h[0]] = trim($h[1]);
+                } elseif (is_array($headers[$h[0]])) {
+                    $headers[$h[0]] = array_merge($headers[$h[0]], array(trim($h[1])));
+                } else {
+                    $headers[$h[0]] = array_merge(array($headers[$h[0]]), array(trim($h[1])));
+                }
+
+                $key = $h[0];
+            } else {
+                if (substr($h[0], 0, 1) == "\t") {
+                    $headers[$key] .= "\r\n\t".trim($h[0]);
+                } elseif (!$key) {
+                    $headers[0] = trim($h[0]);
+                }
+            }
+        }
+
+        return $headers;
+    }
+
+    /**
+     * @param string $body
+     * @return array
+     * @throws Exception
+     */
+    public function parseBody($body)
+    {
+        $contents = $this->splitContent($body);
+        if (!is_array($contents) || empty($contents)) {
+            throw new Exception('Empty response.');
+        }
+        $parsedResponse = array();
+        foreach ($contents as $content) {
+            if ($this->uuid == null) {
+                $uuidStart = strpos($content, self::UUID, 0) + strlen(self::UUID);
+                $uuidEnd = strpos($content, self::NEW_LINE_CHAR, $uuidStart);
+                $this->uuid = substr($content, $uuidStart, $uuidEnd - $uuidStart);
+            }
+            $headers = $this->extractHeader($content);
+            if (count($headers) > 0) {
+                if (isset($headers['Content-ID'])) {
+                    $parsedResponse[$headers['Content-ID']] = trim(substr($content, $headers['offsetEnd']));
+                }
+            }
+        }
+        if (empty($parsedResponse)) {
+            throw new Exception('Response cannot be parsed.');
+        }
+
+        return $parsedResponse;
+    }
+
+    /**
+     * @param array $parsedHeaders
+     * @return bool|string
+     */
+    public function parseContentType($parsedHeaders)
+    {
+        if (!isset($parsedHeaders['Content-Type'])) {
+            return false;
+        }
+        $contentTypes = explode(';', $parsedHeaders['Content-Type']);
+        foreach ($contentTypes as $contentType) {
+            if (strpos($contentType, 'start=') !== false) {
+                return substr($contentType, 8, -1);
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param string $response
+     * @return array
+     */
+    private static function splitContent($response)
+    {
+        $contents = array();
+        $matches = array();
+        preg_match_all(self::UUID, $response, $matches, PREG_OFFSET_CAPTURE);
+        for ($i = 0; $i < count($matches[0]) - 1; $i++) {
+            if ($i + 1 < count($matches[0])) {
+                $contents[$i] = substr(
+                    $response,
+                    $matches[0][$i][1],
+                    $matches[0][$i + 1][1] - $matches[0][$i][1]
+                );
+            } else {
+                $contents[$i] = substr(
+                    $response,
+                    $matches[0][$i][1],
+                    strlen($response)
+                );
+            }
+        }
+
+        return $contents;
+    }
+
+    /**
+     * @param string $part
+     * @return array
+     */
+    private function extractHeader($part)
+    {
+        $header = array();
+        $headerLineStart = strpos($part, 'Content-', 0);
+        $endLine = 0;
+        while ($headerLineStart !== false) {
+            $header['offsetStart'] = $headerLineStart;
+            $endLine = strpos($part, self::NEW_LINE_CHAR, $headerLineStart);
+            $headerLine = explode(': ', substr($part, $headerLineStart, $endLine - $headerLineStart));
+            $header[$headerLine[0]] = $headerLine[1];
+            $headerLineStart = strpos($part, 'Content-', $endLine);
+        }
+        $header['offsetEnd'] = $endLine;
+
+        return $header;
+    }
+}

modules/colissimo/lib/Response/ColissimoReturnedResponseInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+/**
+ * Interface ColissimoReturnedResponseInterface
+ */
+interface ColissimoReturnedResponseInterface
+{
+    /**
+     * @param string $responseHeader
+     * @param string $responseBody
+     * @return mixed
+     */
+    public static function buildFromResponse($responseHeader, $responseBody);
+}

modules/colissimo/lib/Response/ColissimoTrackingEnrichiResponse.php

@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * Class ColissimoTrackingEnrichiResponse
+ */
+class ColissimoTrackingEnrichiResponse extends AbstractColissimoResponse implements ColissimoReturnedResponseInterface
+{
+    /** @var array $parcel */
+    public $parcel;
+
+    /** @var array $error */
+    public $error;
+
+    /** @var array $message */
+    public $message;
+
+    /** @var string $code */
+    public $code;
+
+    /** @var string $messageCode */
+    public $messageCode;
+
+    /**
+     * @param mixed $responseHeader
+     * @param mixed $responseBody
+     * @return mixed
+     * @throws Exception
+     */
+    public static function buildFromResponse($responseHeader, $responseBody)
+    {
+        $trackingEnrichiResponse = new self();
+        $responseArray = json_decode($responseBody, true);
+        if (!empty($responseArray)) {
+            $trackingEnrichiResponse->response = $responseArray;
+            if (isset($responseArray['code'])) {
+                $trackingEnrichiResponse->code = $responseArray['code'];
+            }
+            if (isset($responseArray['messageCode'])) {
+                $trackingEnrichiResponse->messageCode = $responseArray['messageCode'];
+            }
+            if (isset($responseArray['message'])) {
+                $trackingEnrichiResponse->message = $responseArray['message'];
+            }
+            if (isset($responseArray['error'])) {
+                $trackingEnrichiResponse->error = $responseArray['error'];
+            }
+            if (isset($responseArray['parcel'])) {
+                $trackingEnrichiResponse->parcel = $responseArray['parcel'];
+            }
+        }
+
+        return $trackingEnrichiResponse;
+    }
+}

modules/colissimo/lib/Response/ColissimoTrackingSimpleResponse.php

@@ -0,0 +1,45 @@
+<?php
+
+/**
+ * Class ColissimoTrackingSimpleResponse
+ */
+class ColissimoTrackingSimpleResponse extends AbstractColissimoResponse implements ColissimoReturnedResponseInterface
+{
+    public $errorMessage;
+    public $errorCode;
+    public $eventCode;
+    public $eventDate;
+    public $eventLibelle;
+    public $eventSite;
+    public $recipientCity;
+    public $recipientCountryCode;
+    public $recipientZipCode;
+    public $skybillNumber;
+
+    /**
+     * @param mixed $responseHeader
+     * @param mixed $responseBody
+     * @return mixed
+     * @throws Exception
+     */
+    public static function buildFromResponse($responseHeader, $responseBody)
+    {
+        $trackingSimpleResponse = new self();
+        $xml = new SimpleXMLElement($responseBody);
+        $xml->registerXPathNamespace('ns1', 'http://chargeur.tracking.geopost.com/');
+        $return = $xml->xpath('soap:Body/ns1:trackResponse/return');
+        $array = json_decode(json_encode($return[0]), true);
+        $trackingSimpleResponse->errorMessage = isset($array['errorMessage']) ? $array['errorMessage'] : null;
+        $trackingSimpleResponse->errorCode = isset($array['errorCode']) ? $array['errorCode'] : null;
+        $trackingSimpleResponse->eventCode = isset($array['eventCode']) ? $array['eventCode'] : null;
+        $trackingSimpleResponse->eventDate = isset($array['eventDate']) ? $array['eventDate'] : null;
+        $trackingSimpleResponse->eventLibelle = isset($array['eventLibelle']) ? $array['eventLibelle'] : null;
+        $trackingSimpleResponse->eventSite = isset($array['eventSite']) ? $array['eventSite'] : null;
+        $trackingSimpleResponse->recipientCity = isset($array['recipientCity']) ? $array['recipientCity'] : null;
+        $trackingSimpleResponse->recipientCountryCode = isset($array['recipientCountryCode']) ? $array['recipientCountryCode'] : null;
+        $trackingSimpleResponse->recipientZipCode = isset($array['recipientZipCode']) ? $array['recipientZipCode'] : null;
+        $trackingSimpleResponse->skybillNumber = isset($array['skybillNumber']) ? $array['skybillNumber'] : null;
+
+        return $trackingSimpleResponse;
+    }
+}

modules/colissimo/lib/Response/ColissimoTrackingTimelineResponse.php

@@ -0,0 +1,56 @@
+<?php
+
+/**
+ * Class ColissimoTrackingTimelineResponse
+ */
+class ColissimoTrackingTimelineResponse extends AbstractColissimoResponse implements ColissimoReturnedResponseInterface
+{
+    /** @var array $status */
+    public $status;
+
+    /** @var array $userMessages */
+    public $userMessages;
+
+    /** @var array $parcelDetails */
+    public $parcelDetails;
+
+    /** @var array $events */
+    public $events;
+
+    /** @var array $timeline */
+    public $timeline;
+
+    /**
+     * @param mixed $responseHeader
+     * @param mixed $responseBody
+     * @return mixed
+     * @throws Exception
+     */
+    public static function buildFromResponse($responseHeader, $responseBody)
+    {
+        $trackingTimelineResponse = new self();
+        $responseArray = json_decode($responseBody, true);
+        if (!empty($responseArray)) {
+            $trackingTimelineResponse->response = $responseArray;
+            if (isset($responseArray['status'])) {
+                $trackingTimelineResponse->status = $responseArray['status'];
+            }
+            if (isset($responseArray['message'])) {
+                $trackingTimelineResponse->userMessages = $responseArray['message'];
+            }
+            if (isset($responseArray['parcel'])) {
+                $trackingTimelineResponse->parcelDetails = $responseArray['parcel'];
+                if (isset($responseArray['parcel']['event'])) {
+                    $trackingTimelineResponse->events = $responseArray['parcel']['event'];
+                    unset($trackingTimelineResponse->parcelDetails['event']);
+                }
+                if (isset($responseArray['parcel']['step'])) {
+                    $trackingTimelineResponse->timeline = $responseArray['parcel']['step'];
+                    unset($trackingTimelineResponse->parcelDetails['step']);
+                }
+            }
+        }
+
+        return $trackingTimelineResponse;
+    }
+}

modules/colissimo/lib/Response/ColissimoWidgetAuthenticationResponse.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * Class ColissimoWidgetAuthenticationResponse
+ */
+class ColissimoWidgetAuthenticationResponse extends AbstractColissimoResponse implements ColissimoReturnedResponseInterface
+{
+    /** @var string $token */
+    public $token;
+
+    /**
+     * @param mixed $responseHeader
+     * @param mixed $responseBody
+     * @return mixed
+     * @throws Exception
+     */
+    public static function buildFromResponse($responseHeader, $responseBody)
+    {
+        $widgetAuthenticationResponse = new self();
+        $responseArray = json_decode($responseBody, true);
+        if (!empty($responseArray)) {
+            $widgetAuthenticationResponse->response = $responseArray;
+            $widgetAuthenticationResponse->token = $responseArray['token'];
+        }
+
+        return $widgetAuthenticationResponse;
+    }
+}

modules/colissimo/lib/Response/index.php

@@ -0,0 +1,35 @@
+<?php
+/**
+* 2007-2020 PrestaShop
+*
+* NOTICE OF LICENSE
+*
+* This source file is subject to the Academic Free License (AFL 3.0)
+* that is bundled with this package in the file LICENSE.txt.
+* It is also available through the world-wide-web at this URL:
+* http://opensource.org/licenses/afl-3.0.php
+* If you did not receive a copy of the license and are unable to
+* obtain it through the world-wide-web, please send an email
+* to license@prestashop.com so we can send you a copy immediately.
+*
+* DISCLAIMER
+*
+* Do not edit or add to this file if you wish to upgrade PrestaShop to newer
+* versions in the future. If you wish to customize PrestaShop for your
+* needs please refer to http://www.prestashop.com for more information.
+*
+*  @author    PrestaShop SA <contact@prestashop.com>
+*  @copyright 2007-2020 PrestaShop SA
+*  @license   http://opensource.org/licenses/afl-3.0.php  Academic Free License (AFL 3.0)
+*  International Registered Trademark & Property of PrestaShop SA
+*/
+
+header('Expires: Mon, 26 Jul 1997 05:00:00 GMT');
+header('Last-Modified: '.gmdate('D, d M Y H:i:s').' GMT');
+
+header('Cache-Control: no-store, no-cache, must-revalidate');
+header('Cache-Control: post-check=0, pre-check=0', false);
+header('Pragma: no-cache');
+
+header('Location: ../');
+exit;