cwd / datamolino-client

DatamolinoClient.php

<?php

/*
 * This file is part of datamolino client.
 *
 * (c) 2018 cwd.at GmbH <office@cwd.at>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Cwd\Datamolino;

use Cwd\Datamolino\Model\Agenda;
use Cwd\Datamolino\Model\Document;
use Cwd\Datamolino\Model\OriginalFile;
use Cwd\Datamolino\Model\UploadFile;
use Cwd\Datamolino\Model\DocumentFile;
use Cwd\Datamolino\Model\User;
use GuzzleHttp\Psr7\Request;
use Http\Client\HttpClient;
use Symfony\Component\Finder\Finder;
use Symfony\Component\HttpFoundation\File\File as FileInfo;
use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter;
use Symfony\Component\Serializer\Normalizer\DateTimeNormalizer;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;

class DatamolinoClient
{
    public const PAYLOAD_LIMIT = 1024 * 1024 * 20; // 20MB

    private $apiUrl = 'https://beta.datamolino.com';
    private $apiVersion = 'v1_2';
    private $apiUri;
    private $tokenUrl;
    private $token;

    /** @var HttpClient */
    private $client;

    /** @var Serializer */
    private $serializer;

    public function __construct(HttpClient $client)
    {
        $this->client = $client;
        $this->apiUri = sprintf('%s/api/%s/', $this->apiUrl, $this->apiVersion);
        $this->tokenUrl = $this->apiUrl.'/oauth/token';

        $normalizer = new ObjectNormalizer(null, new CamelCaseToSnakeCaseNameConverter(), null, new ReflectionExtractor());
        $this->serializer = new Serializer([new DateTimeNormalizer(), $normalizer], ['json' => new JsonEncoder()]);
    }

    /**
     * @param string|Finder $finder    Location of Files or Finder Instance
     * @param int           $agendaId
     * @param string        $type
     * @param bool          $fileSplit
     * @param bool          $lacyLoad
     *
     * @return Document[]
     *
     * @throws \Http\Client\Exception
     */
    public function createDocuments($finder, int $agendaId, string $type = Document::DOCTYPE_PURCHASE, $fileSplit = false, $lacyLoad = false): array
    {
        $currentFileSize = 0;
        $resultDocuments = [];
        $documentFiles = [];

        if (!$finder instanceof Finder) {
            $finder = (new Finder())->in($finder);
        }

        foreach ($finder as $file) {
            $documentFile = new DocumentFile();
            $documentFile->setType($type)
                         ->setAgendaId($agendaId)
                         ->setFileSplit($fileSplit);

            $mimeType = (new FileInfo($file->getPathname()))->getMimeType();
            $currentFileSize += $file->getSize();
            $documentFile->setFile(
                new UploadFile($file->getFilename(), $mimeType, $file->getContents())
            );

            $documentFiles[] = $documentFile;

            if ($currentFileSize >= self::PAYLOAD_LIMIT) {
                $resultDocuments += $this->sendDocuments($documentFiles, $lacyLoad);
                $documentFiles = [];
            }
        }

        if (count($documentFiles) > 0) {
            $resultDocuments += $this->sendDocuments($documentFiles, $lacyLoad);
        }

        return $resultDocuments;
    }

    /**
     * @param string $fileUri
     * @param int    $agendaId
     * @param string $filename
     * @param string $type
     * @param bool   $fileSplit
     * @param bool   $lacyLoad
     *
     * @return Document
     *
     * @throws \Http\Client\Exception
     */
    public function createDocument($fileUri, $agendaId, $filename, $type = Document::DOCTYPE_PURCHASE, $fileSplit = false, $lacyLoad = false): Document
    {
        $file = new FileInfo($fileUri);
        $mimeType = $file->getMimeType();

        $documentFile = new DocumentFile();
        $documentFile->setType($type)
            ->setAgendaId($agendaId)
            ->setFileSplit($fileSplit)
            ->setFile(
                new UploadFile($file->getFilename(), $mimeType, file_get_contents($file->getPathname()))
            )
        ;

        return current($this->sendDocuments([$documentFile], $lacyLoad));
    }

    /**
     * @param DocumentFile[] $files
     *
     * @return array
     *
     * @throws \Http\Client\Exception
     */
    public function sendDocuments(array $files, $lacyLoad = true)
    {
        $payload = $this->serializer->serialize(['documents' => $files], 'json');
        $documents = $this->call($payload, null, 'documents', Document::class, true, 'POST');

        if ($lacyLoad) {
            $ids = [];
            /** @var Document $document */
            foreach ($documents as $document) {
                $ids[] = $document->getId();
            }

            return $this->getDocuments(current($files)->getAgendaId(), $ids);
        }

        return $documents;
    }

    /**
     * @param $document
     *
     * @return OriginalFile
     *
     * @throws \Http\Client\Exception
     */
    public function getDocumentFile($document): OriginalFile
    {
        if ($document instanceof Document) {
            $document = $document->getId();
        }

        return $this->call(null, $document, 'documents', OriginalFile::class, false, 'GET', '/original_file');
    }

    /**
     * @param int|Document $document
     *
     * @throws \Http\Client\Exception
     */
    public function deleteDocument($document): void
    {
        if ($document instanceof Document) {
            $document = $document->getId();
        }

        $this->call(null, $document, 'documents', null, false, 'DELETE');
    }

    /**
     * @param Document|int $document
     * @param string       $text
     *
     * @throws \Http\Client\Exception
     */
    public function repairDocument($document, $text): void
    {
        if ($document instanceof Document) {
            $document = $document->getId();
        }

        $this->call(null, $document, 'documents', OriginalFile::class, false, 'POST', sprintf(
            '/repair?repair_description=%s', urlencode($text))
        );
    }

    /**
     * @param int            $agendaId
     * @param array          $ids
     * @param \DateTime|null $modifiedSince
     * @param array          $states
     * @param int            $page
     * @param string         $type
     *
     * @return mixed
     *
     * @throws \Http\Client\Exception
     */
    public function getDocuments($agendaId, array $ids = [], ?\DateTime $modifiedSince = null, array $states = [], $page = 1, $type = Document::DOCTYPE_PURCHASE)
    {
        $queryString = [
            sprintf('agenda_id=%s', $agendaId),
            sprintf('page=%s', $page),
            sprintf('type=%s', $type),
        ];

        if (null !== $modifiedSince) {
            $queryString[] = sprintf('modified_since=%s', $modifiedSince->format('Y-m-d\TH:i:s\Z'));
        }

        if (count($states) > 0) {
            foreach ($states as $state) {
                $queryString[] = sprintf('state[]=%s', $state);
            }
        }

        if (count($ids) > 0) {
            foreach ($ids as $id) {
                $queryString[] = sprintf('ids[]=%s', $id);
            }
        }

        return $this->call(null, sprintf('?%s', implode('&', $queryString)), 'documents', Document::class, true, 'GET');
    }

    /**
     * @return Agenda[]
     *
     * @throws \Http\Client\Exception
     */
    public function getAgendas()
    {
        return $this->call(null, null, 'agendas', Agenda::class, true, 'GET');
    }

    /**
     * @param int $id
     *
     * @return Agenda
     *
     * @throws \Http\Client\Exception
     */
    public function getAgenda(int $id): Agenda
    {
        return $this->call(null, $id, 'agendas', Agenda::class, false, 'GET');
    }

    /**
     * @param Agenda $agenda
     * @param bool   $lazyLoad if false the agenda object only holds the ID
     *
     * @return Agenda
     *
     * @throws \Http\Client\Exception
     */
    public function createAgenda(Agenda $agenda, $lazyLoad = false): Agenda
    {
        $payload = $this->serializer->serialize(['agendas' => [$agenda]], 'json');
        $agenda = $this->call($payload, null, 'agendas', Agenda::class, false, 'POST');

        if ($lazyLoad) {
            return $this->getAgenda($agenda->getId());
        }

        return $agenda;
    }

    /**
     * @param Agenda $agenda
     *
     * @return void|
     *
     * @throws \Http\Client\Exception
     */
    public function updateAgenda(Agenda $agenda)
    {
        $payload = $this->serializer->serialize(['agendas' => [$agenda]], 'json');
        $this->call($payload, $agenda->getId(), 'agendas', null, false, 'PUT');
    }

    /**
     * @param Agenda $agenda
     *
     * @return mixed
     *
     * @throws \Http\Client\Exception
     */
    public function deleteAgenda(int $id): void
    {
        $this->call(null, $id, 'agendas', null, false, 'DELETE');
    }

    /**
     * @return User
     *
     * @throws \Http\Client\Exception
     */
    public function getMe(): User
    {
        // Result is different - denormalize by hand
        $data = $this->call(null, null, 'me', null, false, 'GET');

        return $this->denormalizeObject(User::class, [$data], false);
    }

    /**
     * @param string|null     $payload
     * @param int|string|null $id
     * @param string          $endpoint
     * @param string|null     $hydrationClass
     * @param bool            $isList
     * @param string          $method
     * @param string|null     $urlExtension   - Special case only needed when retrieving original file!
     *
     * @return mixed
     *
     * @throws \Http\Client\Exception
     */
    protected function call($payload = null, $id = null, $endpoint = '', $hydrationClass = null, $isList = false, $method = 'POST', $urlExtension = null)
    {
        if (null === $this->token) {
            throw new \Exception('Token not set');
        }

        if (in_array($method, ['GET', 'PUT', 'DELETE'])) {
            $format = (is_int($id)) ? '%s%s/%s' : '%s%s%s';
            $uri = sprintf($format, $this->apiUri, $endpoint, $id);
        } else {
            $uri = (null !== $id) ? sprintf('%s%s/%s', $this->apiUri, $endpoint, $id) : $this->apiUri.$endpoint;
        }

        /* Special case only needed for retrieve original file */
        if (null !== $urlExtension) {
            $uri .= $urlExtension;
        }

        $request = new Request($method, $uri, [
            'Authorization' => sprintf('Bearer %s', $this->token),
            'Content-Type' => 'application/json',
        ], $payload);

        $response = $this->client->sendRequest($request);
        $responseBody = $response->getBody()->getContents();
        $responseData = json_decode($responseBody);

        if ('dev' === getenv('APP_ENV')) {
            dump([$request, $responseData]);
        }

        if ($response->getStatusCode() > 299) {
            $message = isset($responseData->message) ? $responseData->message : 'Unknown';
            throw new \Exception(sprintf('Error on request %s: %s', $response->getStatusCode(), $message));
        }

        if (null !== $hydrationClass && class_exists($hydrationClass) && isset($responseData->$endpoint)) {
            return $this->denormalizeObject($hydrationClass, $responseData->$endpoint, $isList);
        } elseif (null !== $hydrationClass && !class_exists($hydrationClass)) {
            throw new \Exception(sprintf('HydrationClass (%s) does not exist', $hydrationClass));
        } elseif (null !== $hydrationClass && !isset($responseData->$endpoint)) {
            throw new \Exception(sprintf('Datapoint (%s) does not exist', $endpoint));
        }

        return $responseData;
    }

    /**
     * @param string $clientId
     * @param string $clientSecret
     * @param string $username
     * @param string $password
     *
     * @throws \Http\Client\Exception
     * @ToDo Handle Token storage
     */
    public function authenticatePassword($clientId, $clientSecret, $username, $password)
    {
        $request = new Request('POST', $this->tokenUrl, [
            'Content-Type' => 'application/json',
        ], json_encode([
            'client_id' => $clientId,
            'client_secret' => $clientSecret,
            'username' => $username,
            'password' => $password,
            'grant_type' => 'password',
        ]));

        $response = $this->getClient()->sendRequest($request);
        $responseBody = $response->getBody()->getContents();
        dump($responseBody);

The function dump was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    /**
     * @param string $clientId
     * @param string $clientSecret
     * @param string $refreshToken
     *
     * @throws \Http\Client\Exception
     * @ToDo Handle Token storage
     */
    public function refreshToken($clientId, $clientSecret, $refreshToken)
    {
        $request = new Request('POST', $this->tokenUrl, [
            'Content-Type' => 'application/json',
        ], json_encode([
            'client_id' => $clientId,
            'client_secret' => $clientSecret,
            'refresh_token' => $refreshToken,
            'grant_type' => 'refresh_token',
        ]));

        $response = $this->getClient()->sendRequest($request);
        $responseBody = $response->getBody()->getContents();
        dump($responseBody);

The function dump was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    public function setToken($token): DatamolinoClient
    {
        $this->token = $token;

        return $this;
    }

    /**
     * @return string
     */
    public function getApiUrl(): string
    {
        return $this->apiUrl;
    }

    /**
     * @param string $apiUrl
     *
     * @return DatamolinoClient
     */
    public function setApiUrl(string $apiUrl): DatamolinoClient
    {
        $this->apiUrl = $apiUrl;

        return $this;
    }

    /**
     * @return string
     */
    public function getApiVersion(): string
    {
        return $this->apiVersion;
    }

    /**
     * @param string $apiVersion
     *
     * @return DatamolinoClient
     */
    public function setApiVersion(string $apiVersion): DatamolinoClient
    {
        $this->apiVersion = $apiVersion;

        return $this;
    }

    /**
     * @return string
     */
    public function getApiUri(): string
    {
        return $this->apiUri;
    }

    /**
     * @param string $apiUri
     *
     * @return DatamolinoClient
     */
    public function setApiUri(string $apiUri): DatamolinoClient
    {
        $this->apiUri = $apiUri;

        return $this;
    }

    /**
     * @return string
     */
    public function getTokenUrl(): string
    {
        return $this->tokenUrl;
    }

    /**
     * @param string $tokenUrl
     *
     * @return DatamolinoClient
     */
    public function setTokenUrl(string $tokenUrl): DatamolinoClient
    {
        $this->tokenUrl = $tokenUrl;

        return $this;
    }

    protected function denormalizeObject($hydrationClass, $dataObject, $isList = false)
    {
        $result = [];

        foreach ($dataObject as $data) {
            $result[] = $this->serializer->denormalize($data, $hydrationClass, null, [
                ObjectNormalizer::DISABLE_TYPE_ENFORCEMENT => true,
            ]);
        }

        if ($isList) {
            return $result;
        }

        return current($result);
    }

    protected function getClient(): HttpClient
    {
        return $this->client;
    }
}