Client::uploadSessionFinish() - Code Metrics - Inspection of "Upload session" - spatie/dropbox-api - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#21)

unknown

created 2017-07-19 21:26 UTC

Client::uploadSessionFinish() A

↳ Parent: Client

Complexity

Conditions	2
Paths	1

Size

Total Lines	13
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	13
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	8
nc	1
nop	6

<?php

namespace Spatie\Dropbox;

use Exception;
use GuzzleHttp\Psr7\StreamWrapper;
use GuzzleHttp\Client as GuzzleClient;
use Psr\Http\Message\ResponseInterface;
use GuzzleHttp\Exception\ClientException;
use Spatie\Dropbox\Exceptions\BadRequest;

class Client
{
    const THUMBNAIL_FORMAT_JPEG = 'jpeg';
    const THUMBNAIL_FORMAT_PNG = 'png';

    const THUMBNAIL_SIZE_XS = 'w32h32';
    const THUMBNAIL_SIZE_S = 'w64h64';
    const THUMBNAIL_SIZE_M = 'w128h128';
    const THUMBNAIL_SIZE_L = 'w640h480';
    const THUMBNAIL_SIZE_XL = 'w1024h768';

    /** @var string */
    protected $accessToken;

    /** @var \GuzzleHttp\Client */
    protected $client;

    public function __construct(string $accessToken, GuzzleClient $client = null)
    {
        $this->accessToken = $accessToken;

        $this->client = $client ?? new GuzzleClient([
                'headers' => [
                    'Authorization' => "Bearer {$this->accessToken}",
                ],
            ]);
    }

    /**
     * Copy a file or folder to a different location in the user's Dropbox.
     *
     * If the source path is a folder all its contents will be copied.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-copy
     */
    public function copy(string $fromPath, string $toPath): array

    {
        $parameters = [
            'from_path' => $this->normalizePath($fromPath),
            'to_path' => $this->normalizePath($toPath),
        ];

        return $this->rpcEndpointRequest('files/copy', $parameters);
    }

    /**
     * Create a folder at a given path.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-create_folder
     */
    public function createFolder(string $path): array
    {
        $parameters = [
            'path' => $this->normalizePath($path),
        ];

        $object = $this->rpcEndpointRequest('files/create_folder', $parameters);

        $object['.tag'] = 'folder';

        return $object;
    }

    /**
     * Create a shared link with custom settings.
     *
     * If no settings are given then the default visibility is RequestedVisibility.public.
     * The resolved visibility, though, may depend on other aspects such as team and
     * shared folder settings). Only for paid users.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#sharing-create_shared_link_with_settings
     */
    public function createSharedLinkWithSettings(string $path, array $settings = [])

    {
        $parameters = [
            'path' => $this->normalizePath($path),
            'settings' => $settings,
        ];

        return $this->rpcEndpointRequest('sharing/create_shared_link_with_settings', $parameters);
    }

    /**
     * List shared links.
     *
     * For empty path returns a list of all shared links. For non-empty path
     * returns a list of all shared links with access to the given path.
     *
     * If direct_only is set true, only direct links to the path will be returned, otherwise
     * it may return link to the path itself and parent folders as described on docs.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#sharing-list_shared_links
     */
    public function listSharedLinks(string $path = null, bool $direct_only = false, string $cursor = null): array
    {
        $parameters = [
            'path' => $path ? $this->normalizePath($path) : null,
            'cursor' => $cursor,
            'direct_only' => $direct_only,
        ];

        $body = $this->rpcEndpointRequest('sharing/list_shared_links', $parameters);

        return $body['links'];
    }

    /**
     * Delete the file or folder at a given path.
     *
     * If the path is a folder, all its contents will be deleted too.
     * A successful response indicates that the file or folder was deleted.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-delete
     */
    public function delete(string $path): array
    {
        $parameters = [
            'path' => $this->normalizePath($path),
        ];

        return $this->rpcEndpointRequest('files/delete', $parameters);
    }

    /**
     * Download a file from a user's Dropbox.
     *
     * @param string $path
     *
     * @return resource
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-download
     */
    public function download(string $path)
    {
        $arguments = [
            'path' => $this->normalizePath($path),
        ];

        $response = $this->contentEndpointRequest('files/download', $arguments);

        return StreamWrapper::getResource($response->getBody());
    }

    /**
     * Returns the metadata for a file or folder.
     *
     * Note: Metadata for the root folder is unsupported.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-get_metadata
     */
    public function getMetadata(string $path): array
    {
        $parameters = [
            'path' => $this->normalizePath($path),
        ];

        return $this->rpcEndpointRequest('files/get_metadata', $parameters);
    }

    /**
     * Get a temporary link to stream content of a file.
     *
     * This link will expire in four hours and afterwards you will get 410 Gone.
     * Content-Type of the link is determined automatically by the file's mime type.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-get_temporary_link
     */
    public function getTemporaryLink(string $path): string

    {
        $parameters = [
            'path' => $this->normalizePath($path),
        ];

        $body = $this->rpcEndpointRequest('files/get_temporary_link', $parameters);

        return $body['link'];
    }

    /**
     * Get a thumbnail for an image.
     *
     * This method currently supports files with the following file extensions:
     * jpg, jpeg, png, tiff, tif, gif and bmp.
     *
     * Photos that are larger than 20MB in size won't be converted to a thumbnail.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-get_thumbnail
     */
    public function getThumbnail(string $path, string $format = 'jpeg', string $size = 'w64h64'): string
    {
        $arguments = [
            'path' => $this->normalizePath($path),
            'format' => $format,
            'size' => $size,
        ];

        $response = $this->contentEndpointRequest('files/get_thumbnail', $arguments);

        return (string) $response->getBody();
    }

    /**
     * Starts returning the contents of a folder.
     *
     * If the result's ListFolderResult.has_more field is true, call
     * list_folder/continue with the returned ListFolderResult.cursor to retrieve more entries.
     *
     * Note: auth.RateLimitError may be returned if multiple list_folder or list_folder/continue calls
     * with same parameters are made simultaneously by same API app for same user. If your app implements
     * retry logic, please hold off the retry until the previous request finishes.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-list_folder
     */
    public function listFolder(string $path = '', bool $recursive = false): array

    {
        $parameters = [
            'path' => $this->normalizePath($path),
            'recursive' => $recursive,
        ];

        return $this->rpcEndpointRequest('files/list_folder', $parameters);
    }

    /**
     * Once a cursor has been retrieved from list_folder, use this to paginate through all files and
     * retrieve updates to the folder, following the same rules as documented for list_folder.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-list_folder-continue
     */
    public function listFolderContinue(string $cursor = ''): array
    {
        return $this->rpcEndpointRequest('files/list_folder/continue', compact('cursor'));
    }

    /**
     * Move a file or folder to a different location in the user's Dropbox.
     *
     * If the source path is a folder all its contents will be moved.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-move
     */
    public function move(string $fromPath, string $toPath): array

    {
        $parameters = [
            'from_path' => $this->normalizePath($fromPath),
            'to_path' => $this->normalizePath($toPath),
        ];

        return $this->rpcEndpointRequest('files/move', $parameters);
    }

    /**
     * Create a new file with the contents provided in the request.
     *
     * Do not use this to upload a file larger than 150 MB. Instead, create an upload session with upload_session/start.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-upload
     *
     * @param string $path
     * @param string|resource $contents
     * @param string|array $mode
     *
     * @return array
     */
    public function upload(string $path, $contents, $mode = 'add'): array
    {
        $arguments = [
            'path' => $this->normalizePath($path),
            'mode' => $mode,
        ];

        $response = $this->contentEndpointRequest('files/upload', $arguments, $contents);

        $metadata = json_decode($response->getBody(), true);

        $metadata['.tag'] = 'file';

        return $metadata;
    }

    /**
     * Upload file split in chunks. This allows uploading large files, since
     * Dropbox API v2 limits the content size to 150MB.
     *
     * The chunk size will affect directly the memory usage, so be careful.
     * Large chunks tends to speed up the upload, while smaller optimizes memory usage.
     *
     * @param string          $path
     * @param string|resource $contents
     * @param int             $chunkSize
     * @param string          $mode
     *
     * @return array
     */
    public function uploadChunked(string $path, $contents, int $chunkSize, $mode = 'add'): array
    {
        // This method relies on resources, so we need to convert strings to resource
        if (is_string($contents)) {
            $stream = fopen('php://memory', 'r+');
            fwrite($stream, $contents);
            rewind($stream);
        } else {
            $stream = $contents;
        }

        $data = self::readFully($stream, $chunkSize);
        $cursor = null;

        while (! ((strlen($data) < $chunkSize) || feof($stream))) {
            // Start upload session on first iteration, then just append on subsequent iterations
            if (isset($cursor)) {
                $cursor = $this->uploadSessionAppend($data, $cursor);
            } else {
                $cursor = $this->uploadSessionStart($data);
            }

            $data = self::readFully($stream, $chunkSize);
        }

        // If there's no cursor here, our stream is small enough to a single request
        if (! isset($cursor)) {
            $cursor = $this->uploadSessionStart($data);
            $data = '';
        }

        return $this->uploadSessionFinish($data, $cursor, $path, $mode);
    }

    /**
     * Upload sessions allow you to upload a single file in one or more requests,
     * for example where the size of the file is greater than 150 MB.
     * This call starts a new upload session with the given data.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-upload_session-start
     *
     * @param string $contents
     * @param bool   $close
     *
     * @return UploadSessionCursor
     */
    public function uploadSessionStart($contents, bool $close = false): UploadSessionCursor
    {
        $arguments = compact('close');

        $response = json_decode(
            $this->contentEndpointRequest('files/upload_session/start', $arguments, $contents)->getBody(),
            true
        );

        return new UploadSessionCursor($response['session_id'], strlen($contents));
    }

    /**
     * Append more data to an upload session.
     * When the parameter close is set, this call will close the session.
     * A single request should not upload more than 150 MB.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-upload_session-append_v2
     *
     * @param string              $contents
     * @param UploadSessionCursor $cursor
     * @param bool                $close
     *
     * @return \Spatie\Dropbox\UploadSessionCursor
     */
    public function uploadSessionAppend($contents, UploadSessionCursor $cursor, bool $close = false): UploadSessionCursor
    {
        $arguments = compact('cursor', 'close');

        $this->contentEndpointRequest('files/upload_session/append_v2', $arguments, $contents);

        $cursor->offset += strlen($contents);

        return $cursor;
    }

    /**
     * Finish an upload session and save the uploaded data to the given file path.
     * A single request should not upload more than 150 MB.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#files-upload_session-finish
     *
     * @param string                              $contents
     * @param \Spatie\Dropbox\UploadSessionCursor $cursor
     * @param string                              $path
     * @param string|array                        $mode
     * @param bool                                $autorename
     * @param bool                                $mute
     *
     * @return array
     */
    public function uploadSessionFinish($contents, UploadSessionCursor $cursor, string $path, $mode = 'add', $autorename = false, $mute = false): array
    {
        $arguments = compact('cursor');
        $arguments['commit'] = compact('path', 'mode', 'autorename', 'mute');

        $response = $this->contentEndpointRequest(
            'files/upload_session/finish',
            $arguments,
            ($contents == '') ? null : $contents
        );

        return json_decode($response->getBody(), true);
    }

    /**
     * Sometimes fread() returns less than the request number of bytes (for example, when reading
     * from network streams).  This function repeatedly calls fread until the requested number of
     * bytes have been read or we've reached EOF.
     *
     * @param resource $inStream
     * @param int      $numBytes
     * @throws Exception
     * @return string
     */
    private static function readFully($inStream, int $numBytes)
    {
        $full = '';
        $bytesRemaining = $numBytes;
        while (! feof($inStream) && $bytesRemaining > 0) {
            $part = fread($inStream, $bytesRemaining);
            if ($part === false) {
                throw new Exception('Error reading from $inStream.');
            }
            $full .= $part;
            $bytesRemaining -= strlen($part);
        }

        return $full;
    }

    /**
     * Get Account Info for current authenticated user.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#users-get_current_account
     *
     * @return array
     */
    public function getAccountInfo(): array
    {
        return $this->rpcEndpointRequest('users/get_current_account');
    }

    /**
     * Revoke current access token.
     *
     * @link https://www.dropbox.com/developers/documentation/http/documentation#auth-token-revoke
     */
    public function revokeToken()
    {
        $this->rpcEndpointRequest('auth/token/revoke');
    }

    protected function normalizePath(string $path): string
    {
        $path = trim($path, '/');

        return ($path === '') ? '' : '/'.$path;
    }

    /**
     * @param string $endpoint
     * @param array $arguments
     * @param string|resource $body
     *
     * @return \Psr\Http\Message\ResponseInterface
     *
     * @throws \Exception
     */
    public function contentEndpointRequest(string $endpoint, array $arguments, $body = ''): ResponseInterface
    {
        $headers['Dropbox-API-Arg'] = json_encode($arguments);
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}

        if ($body !== '') {
            $headers['Content-Type'] = 'application/octet-stream';
        }

        try {
            $response = $this->client->post("https://content.dropboxapi.com/2/{$endpoint}", [
                'headers' => $headers,
                'body' => $body,
            ]);
        } catch (ClientException $exception) {
            throw $this->determineException($exception);
        }

        return $response;
    }

    public function rpcEndpointRequest(string $endpoint, array $parameters = null): array
    {
        try {
            $options = [];

            if ($parameters) {
                $options['json'] = $parameters;
            }

            $response = $this->client->post("https://api.dropboxapi.com/2/{$endpoint}", $options);
        } catch (ClientException $exception) {
            throw $this->determineException($exception);
        }

        $response = json_decode($response->getBody(), true);

        return $response ?? [];
    }

    protected function determineException(ClientException $exception): Exception
    {
        if (in_array($exception->getResponse()->getStatusCode(), [400, 409])) {
            return new BadRequest($exception->getResponse());
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        }

        return $exception;
    }
}


1		<?php
2
3		namespace Spatie\Dropbox;
4
5		use Exception;
6		use GuzzleHttp\Psr7\StreamWrapper;
7		use GuzzleHttp\Client as GuzzleClient;
8		use Psr\Http\Message\ResponseInterface;
9		use GuzzleHttp\Exception\ClientException;
10		use Spatie\Dropbox\Exceptions\BadRequest;
11
12		class Client
13		{
14		const THUMBNAIL_FORMAT_JPEG = 'jpeg';
15		const THUMBNAIL_FORMAT_PNG = 'png';
16
17		const THUMBNAIL_SIZE_XS = 'w32h32';
18		const THUMBNAIL_SIZE_S = 'w64h64';
19		const THUMBNAIL_SIZE_M = 'w128h128';
20		const THUMBNAIL_SIZE_L = 'w640h480';
21		const THUMBNAIL_SIZE_XL = 'w1024h768';
22
23		/** @var string */
24		protected $accessToken;
25
26		/** @var \GuzzleHttp\Client */
27		protected $client;
28
29		public function __construct(string $accessToken, GuzzleClient $client = null)
30		{
31		$this->accessToken = $accessToken;
32
33		$this->client = $client ?? new GuzzleClient([
34		'headers' => [
35		'Authorization' => "Bearer {$this->accessToken}",
36		],
37		]);
38		}
39
40		/**
41		* Copy a file or folder to a different location in the user's Dropbox.
42		*
43		* If the source path is a folder all its contents will be copied.
44		*
45		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-copy
46		*/
47	View Code Duplication	public function copy(string $fromPath, string $toPath): array
		0 ignored issues – show Duplication introduced 2017-04-19 08:22 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
48		{
49		$parameters = [
50		'from_path' => $this->normalizePath($fromPath),
51		'to_path' => $this->normalizePath($toPath),
52		];
53
54		return $this->rpcEndpointRequest('files/copy', $parameters);
55		}
56
57		/**
58		* Create a folder at a given path.
59		*
60		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-create_folder
61		*/
62		public function createFolder(string $path): array
63		{
64		$parameters = [
65		'path' => $this->normalizePath($path),
66		];
67
68		$object = $this->rpcEndpointRequest('files/create_folder', $parameters);
69
70		$object['.tag'] = 'folder';
71
72		return $object;
73		}
74
75		/**
76		* Create a shared link with custom settings.
77		*
78		* If no settings are given then the default visibility is RequestedVisibility.public.
79		* The resolved visibility, though, may depend on other aspects such as team and
80		* shared folder settings). Only for paid users.
81		*
82		* @link https://www.dropbox.com/developers/documentation/http/documentation#sharing-create_shared_link_with_settings
83		*/
84	View Code Duplication	public function createSharedLinkWithSettings(string $path, array $settings = [])
		0 ignored issues – show Duplication introduced 2017-07-08 15:48 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
85		{
86		$parameters = [
87		'path' => $this->normalizePath($path),
88		'settings' => $settings,
89		];
90
91		return $this->rpcEndpointRequest('sharing/create_shared_link_with_settings', $parameters);
92		}
93
94		/**
95		* List shared links.
96		*
97		* For empty path returns a list of all shared links. For non-empty path
98		* returns a list of all shared links with access to the given path.
99		*
100		* If direct_only is set true, only direct links to the path will be returned, otherwise
101		* it may return link to the path itself and parent folders as described on docs.
102		*
103		* @link https://www.dropbox.com/developers/documentation/http/documentation#sharing-list_shared_links
104		*/
105		public function listSharedLinks(string $path = null, bool $direct_only = false, string $cursor = null): array
106		{
107		$parameters = [
108		'path' => $path ? $this->normalizePath($path) : null,
109		'cursor' => $cursor,
110		'direct_only' => $direct_only,
111		];
112
113		$body = $this->rpcEndpointRequest('sharing/list_shared_links', $parameters);
114
115		return $body['links'];
116		}
117
118		/**
119		* Delete the file or folder at a given path.
120		*
121		* If the path is a folder, all its contents will be deleted too.
122		* A successful response indicates that the file or folder was deleted.
123		*
124		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-delete
125		*/
126		public function delete(string $path): array
127		{
128		$parameters = [
129		'path' => $this->normalizePath($path),
130		];
131
132		return $this->rpcEndpointRequest('files/delete', $parameters);
133		}
134
135		/**
136		* Download a file from a user's Dropbox.
137		*
138		* @param string $path
139		*
140		* @return resource
141		*
142		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-download
143		*/
144		public function download(string $path)
145		{
146		$arguments = [
147		'path' => $this->normalizePath($path),
148		];
149
150		$response = $this->contentEndpointRequest('files/download', $arguments);
151
152		return StreamWrapper::getResource($response->getBody());
153		}
154
155		/**
156		* Returns the metadata for a file or folder.
157		*
158		* Note: Metadata for the root folder is unsupported.
159		*
160		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-get_metadata
161		*/
162		public function getMetadata(string $path): array
163		{
164		$parameters = [
165		'path' => $this->normalizePath($path),
166		];
167
168		return $this->rpcEndpointRequest('files/get_metadata', $parameters);
169		}
170
171		/**
172		* Get a temporary link to stream content of a file.
173		*
174		* This link will expire in four hours and afterwards you will get 410 Gone.
175		* Content-Type of the link is determined automatically by the file's mime type.
176		*
177		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-get_temporary_link
178		*/
179	View Code Duplication	public function getTemporaryLink(string $path): string
		0 ignored issues – show Duplication introduced 2017-04-19 08:22 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
180		{
181		$parameters = [
182		'path' => $this->normalizePath($path),
183		];
184
185		$body = $this->rpcEndpointRequest('files/get_temporary_link', $parameters);
186
187		return $body['link'];
188		}
189
190		/**
191		* Get a thumbnail for an image.
192		*
193		* This method currently supports files with the following file extensions:
194		* jpg, jpeg, png, tiff, tif, gif and bmp.
195		*
196		* Photos that are larger than 20MB in size won't be converted to a thumbnail.
197		*
198		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-get_thumbnail
199		*/
200		public function getThumbnail(string $path, string $format = 'jpeg', string $size = 'w64h64'): string
201		{
202		$arguments = [
203		'path' => $this->normalizePath($path),
204		'format' => $format,
205		'size' => $size,
206		];
207
208		$response = $this->contentEndpointRequest('files/get_thumbnail', $arguments);
209
210		return (string) $response->getBody();
211		}
212
213		/**
214		* Starts returning the contents of a folder.
215		*
216		* If the result's ListFolderResult.has_more field is true, call
217		* list_folder/continue with the returned ListFolderResult.cursor to retrieve more entries.
218		*
219		* Note: auth.RateLimitError may be returned if multiple list_folder or list_folder/continue calls
220		* with same parameters are made simultaneously by same API app for same user. If your app implements
221		* retry logic, please hold off the retry until the previous request finishes.
222		*
223		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-list_folder
224		*/
225	View Code Duplication	public function listFolder(string $path = '', bool $recursive = false): array
		0 ignored issues – show Duplication introduced 2017-04-19 08:22 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
226		{
227		$parameters = [
228		'path' => $this->normalizePath($path),
229		'recursive' => $recursive,
230		];
231
232		return $this->rpcEndpointRequest('files/list_folder', $parameters);
233		}
234
235		/**
236		* Once a cursor has been retrieved from list_folder, use this to paginate through all files and
237		* retrieve updates to the folder, following the same rules as documented for list_folder.
238		*
239		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-list_folder-continue
240		*/
241		public function listFolderContinue(string $cursor = ''): array
242		{
243		return $this->rpcEndpointRequest('files/list_folder/continue', compact('cursor'));
244		}
245
246		/**
247		* Move a file or folder to a different location in the user's Dropbox.
248		*
249		* If the source path is a folder all its contents will be moved.
250		*
251		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-move
252		*/
253	View Code Duplication	public function move(string $fromPath, string $toPath): array
		0 ignored issues – show Duplication introduced 2017-04-19 08:22 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
254		{
255		$parameters = [
256		'from_path' => $this->normalizePath($fromPath),
257		'to_path' => $this->normalizePath($toPath),
258		];
259
260		return $this->rpcEndpointRequest('files/move', $parameters);
261		}
262
263		/**
264		* Create a new file with the contents provided in the request.
265		*
266		* Do not use this to upload a file larger than 150 MB. Instead, create an upload session with upload_session/start.
267		*
268		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-upload
269		*
270		* @param string $path
271		* @param string\|resource $contents
272		* @param string\|array $mode
273		*
274		* @return array
275		*/
276		public function upload(string $path, $contents, $mode = 'add'): array
277		{
278		$arguments = [
279		'path' => $this->normalizePath($path),
280		'mode' => $mode,
281		];
282
283		$response = $this->contentEndpointRequest('files/upload', $arguments, $contents);
284
285		$metadata = json_decode($response->getBody(), true);
286
287		$metadata['.tag'] = 'file';
288
289		return $metadata;
290		}
291
292		/**
293		* Upload file split in chunks. This allows uploading large files, since
294		* Dropbox API v2 limits the content size to 150MB.
295		*
296		* The chunk size will affect directly the memory usage, so be careful.
297		* Large chunks tends to speed up the upload, while smaller optimizes memory usage.
298		*
299		* @param string $path
300		* @param string\|resource $contents
301		* @param int $chunkSize
302		* @param string $mode
303		*
304		* @return array
305		*/
306		public function uploadChunked(string $path, $contents, int $chunkSize, $mode = 'add'): array
307		{
308		// This method relies on resources, so we need to convert strings to resource
309		if (is_string($contents)) {
310		$stream = fopen('php://memory', 'r+');
311		fwrite($stream, $contents);
312		rewind($stream);
313		} else {
314		$stream = $contents;
315		}
316
317		$data = self::readFully($stream, $chunkSize);
318		$cursor = null;
319
320		while (! ((strlen($data) < $chunkSize) \|\| feof($stream))) {
321		// Start upload session on first iteration, then just append on subsequent iterations
322		if (isset($cursor)) {
323		$cursor = $this->uploadSessionAppend($data, $cursor);
324		} else {
325		$cursor = $this->uploadSessionStart($data);
326		}
327
328		$data = self::readFully($stream, $chunkSize);
329		}
330
331		// If there's no cursor here, our stream is small enough to a single request
332		if (! isset($cursor)) {
333		$cursor = $this->uploadSessionStart($data);
334		$data = '';
335		}
336
337		return $this->uploadSessionFinish($data, $cursor, $path, $mode);
338		}
339
340		/**
341		* Upload sessions allow you to upload a single file in one or more requests,
342		* for example where the size of the file is greater than 150 MB.
343		* This call starts a new upload session with the given data.
344		*
345		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-upload_session-start
346		*
347		* @param string $contents
348		* @param bool $close
349		*
350		* @return UploadSessionCursor
351		*/
352		public function uploadSessionStart($contents, bool $close = false): UploadSessionCursor
353		{
354		$arguments = compact('close');
355
356		$response = json_decode(
357		$this->contentEndpointRequest('files/upload_session/start', $arguments, $contents)->getBody(),
358		true
359		);
360
361		return new UploadSessionCursor($response['session_id'], strlen($contents));
362		}
363
364		/**
365		* Append more data to an upload session.
366		* When the parameter close is set, this call will close the session.
367		* A single request should not upload more than 150 MB.
368		*
369		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-upload_session-append_v2
370		*
371		* @param string $contents
372		* @param UploadSessionCursor $cursor
373		* @param bool $close
374		*
375		* @return \Spatie\Dropbox\UploadSessionCursor
376		*/
377		public function uploadSessionAppend($contents, UploadSessionCursor $cursor, bool $close = false): UploadSessionCursor
378		{
379		$arguments = compact('cursor', 'close');
380
381		$this->contentEndpointRequest('files/upload_session/append_v2', $arguments, $contents);
382
383		$cursor->offset += strlen($contents);
384
385		return $cursor;
386		}
387
388		/**
389		* Finish an upload session and save the uploaded data to the given file path.
390		* A single request should not upload more than 150 MB.
391		*
392		* @link https://www.dropbox.com/developers/documentation/http/documentation#files-upload_session-finish
393		*
394		* @param string $contents
395		* @param \Spatie\Dropbox\UploadSessionCursor $cursor
396		* @param string $path
397		* @param string\|array $mode
398		* @param bool $autorename
399		* @param bool $mute
400		*
401		* @return array
402		*/
403		public function uploadSessionFinish($contents, UploadSessionCursor $cursor, string $path, $mode = 'add', $autorename = false, $mute = false): array
404		{
405		$arguments = compact('cursor');
406		$arguments['commit'] = compact('path', 'mode', 'autorename', 'mute');
407
408		$response = $this->contentEndpointRequest(
409		'files/upload_session/finish',
410		$arguments,
411		($contents == '') ? null : $contents
412		);
413
414		return json_decode($response->getBody(), true);
415		}
416
417		/**
418		* Sometimes fread() returns less than the request number of bytes (for example, when reading
419		* from network streams). This function repeatedly calls fread until the requested number of
420		* bytes have been read or we've reached EOF.
421		*
422		* @param resource $inStream
423		* @param int $numBytes
424		* @throws Exception
425		* @return string
426		*/
427		private static function readFully($inStream, int $numBytes)
428		{
429		$full = '';
430		$bytesRemaining = $numBytes;
431		while (! feof($inStream) && $bytesRemaining > 0) {
432		$part = fread($inStream, $bytesRemaining);
433		if ($part === false) {
434		throw new Exception('Error reading from $inStream.');
435		}
436		$full .= $part;
437		$bytesRemaining -= strlen($part);
438		}
439
440		return $full;
441		}
442
443		/**
444		* Get Account Info for current authenticated user.
445		*
446		* @link https://www.dropbox.com/developers/documentation/http/documentation#users-get_current_account
447		*
448		* @return array
449		*/
450		public function getAccountInfo(): array
451		{
452		return $this->rpcEndpointRequest('users/get_current_account');
453		}
454
455		/**
456		* Revoke current access token.
457		*
458		* @link https://www.dropbox.com/developers/documentation/http/documentation#auth-token-revoke
459		*/
460		public function revokeToken()
461		{
462		$this->rpcEndpointRequest('auth/token/revoke');
463		}
464
465		protected function normalizePath(string $path): string
466		{
467		$path = trim($path, '/');
468
469		return ($path === '') ? '' : '/'.$path;
470		}
471
472		/**
473		* @param string $endpoint
474		* @param array $arguments
475		* @param string\|resource $body
476		*
477		* @return \Psr\Http\Message\ResponseInterface
478		*
479		* @throws \Exception
480		*/
481		public function contentEndpointRequest(string $endpoint, array $arguments, $body = ''): ResponseInterface
482		{
483		$headers['Dropbox-API-Arg'] = json_encode($arguments);
		0 ignored issues – show Coding Style Comprehensibility introduced 2017-04-19 09:11 UTC by Report Bug Copy Issue Report `$headers` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$headers = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
484
485		if ($body !== '') {
486		$headers['Content-Type'] = 'application/octet-stream';
487		}
488
489		try {
490		$response = $this->client->post("https://content.dropboxapi.com/2/{$endpoint}", [
491		'headers' => $headers,
492		'body' => $body,
493		]);
494		} catch (ClientException $exception) {
495		throw $this->determineException($exception);
496		}
497
498		return $response;
499		}
500
501		public function rpcEndpointRequest(string $endpoint, array $parameters = null): array
502		{
503		try {
504		$options = [];
505
506		if ($parameters) {
507		$options['json'] = $parameters;
508		}
509
510		$response = $this->client->post("https://api.dropboxapi.com/2/{$endpoint}", $options);
511		} catch (ClientException $exception) {
512		throw $this->determineException($exception);
513		}
514
515		$response = json_decode($response->getBody(), true);
516
517		return $response ?? [];
518		}
519
520		protected function determineException(ClientException $exception): Exception
521		{
522		if (in_array($exception->getResponse()->getStatusCode(), [400, 409])) {
523		return new BadRequest($exception->getResponse());
		0 ignored issues – show Bug introduced 2017-04-19 09:39 UTC by Report Bug Copy Issue Report It seems like `$exception->getResponse()` can be `null`; however, `__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
524		}
525
526		return $exception;
527		}
528		}
529

spatie / dropbox-api

GitHub Access Token became invalid

Pull Request — master (#21)

Client::uploadSessionFinish() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like