TheRakeshPurohit / rtCamp

lib/Google/Http/REST.php

Indentation +82 added lines, -82 removed lines

@@ -27,23 +27,23 @@ 
  */
 class Google_Http_REST
 {
-  /**
-   * Executes a Psr\Http\Message\RequestInterface and (if applicable) automatically retries
-   * when errors occur.
-   *
-   * @param Google_Client $client
-   * @param Psr\Http\Message\RequestInterface $req
-   * @return array decoded result
-   * @throws Google_Service_Exception on server side error (ie: not authenticated,
-   *  invalid or malformed post body, invalid url)
-   */
-  public static function execute(
-      ClientInterface $client,
-      RequestInterface $request,
-      $expectedClass = null,
-      $config = array(),
-      $retryMap = null
-  ) {
+    /**
+     * Executes a Psr\Http\Message\RequestInterface and (if applicable) automatically retries
+     * when errors occur.
+     *
+     * @param Google_Client $client
+     * @param Psr\Http\Message\RequestInterface $req
+     * @return array decoded result
+     * @throws Google_Service_Exception on server side error (ie: not authenticated,
+     *  invalid or malformed post body, invalid url)
+     */
+    public static function execute(
+        ClientInterface $client,
+        RequestInterface $request,
+        $expectedClass = null,
+        $config = array(),
+        $retryMap = null
+    ) {
     $runner = new Google_Task_Runner(
         $config,
         sprintf('%s %s', $request->getMethod(), (string) $request->getUri()),
@@ -52,35 +52,35 @@ 
     );
 
     if (null !== $retryMap) {
-      $runner->setRetryMap($retryMap);
+        $runner->setRetryMap($retryMap);
     }
 
     return $runner->run();
-  }
-
-  /**
-   * Executes a Psr\Http\Message\RequestInterface
-   *
-   * @param Google_Client $client
-   * @param Psr\Http\Message\RequestInterface $request
-   * @return array decoded result
-   * @throws Google_Service_Exception on server side error (ie: not authenticated,
-   *  invalid or malformed post body, invalid url)
-   */
-  public static function doExecute(ClientInterface $client, RequestInterface $request, $expectedClass = null)
-  {
+    }
+
+    /**
+     * Executes a Psr\Http\Message\RequestInterface
+     *
+     * @param Google_Client $client
+     * @param Psr\Http\Message\RequestInterface $request
+     * @return array decoded result
+     * @throws Google_Service_Exception on server side error (ie: not authenticated,
+     *  invalid or malformed post body, invalid url)
+     */
+    public static function doExecute(ClientInterface $client, RequestInterface $request, $expectedClass = null)
+    {
     try {
-      $httpHandler = HttpHandlerFactory::build($client);
-      $response = $httpHandler($request);
+        $httpHandler = HttpHandlerFactory::build($client);
+        $response = $httpHandler($request);
     } catch (RequestException $e) {
-      // if Guzzle throws an exception, catch it and handle the response
-      if (!$e->hasResponse()) {
+        // if Guzzle throws an exception, catch it and handle the response
+        if (!$e->hasResponse()) {
         throw $e;
-      }
+        }
 
-      $response = $e->getResponse();
-      // specific checking for Guzzle 5: convert to PSR7 response
-      if ($response instanceof \GuzzleHttp\Message\ResponseInterface) {
+        $response = $e->getResponse();
+        // specific checking for Guzzle 5: convert to PSR7 response
+        if ($response instanceof \GuzzleHttp\Message\ResponseInterface) {
         $response = new Response(
             $response->getStatusCode(),
             $response->getHeaders() ?: [],
@@ -88,34 +88,34 @@ 
             $response->getProtocolVersion(),
             $response->getReasonPhrase()
         );
-      }
+        }
     }
 
     return self::decodeHttpResponse($response, $request, $expectedClass);
-  }
-
-  /**
-   * Decode an HTTP Response.
-   * @static
-   * @throws Google_Service_Exception
-   * @param Psr\Http\Message\RequestInterface $response The http response to be decoded.
-   * @param Psr\Http\Message\ResponseInterface $response
-   * @return mixed|null
-   */
-  public static function decodeHttpResponse(
-      ResponseInterface $response,
-      RequestInterface $request = null,
-      $expectedClass = null
-  ) {
+    }
+
+    /**
+     * Decode an HTTP Response.
+     * @static
+     * @throws Google_Service_Exception
+     * @param Psr\Http\Message\RequestInterface $response The http response to be decoded.
+     * @param Psr\Http\Message\ResponseInterface $response
+     * @return mixed|null
+     */
+    public static function decodeHttpResponse(
+        ResponseInterface $response,
+        RequestInterface $request = null,
+        $expectedClass = null
+    ) {
     $code = $response->getStatusCode();
 
     // retry strategy
     if (intVal($code) >= 400) {
-      // if we errored out, it should be safe to grab the response body
-      $body = (string) $response->getBody();
+        // if we errored out, it should be safe to grab the response body
+        $body = (string) $response->getBody();
 
-      // Check if we received errors, and add those to the Exception for convenience
-      throw new Google_Service_Exception($body, $code, null, self::getResponseErrors($body));
+        // Check if we received errors, and add those to the Exception for convenience
+        throw new Google_Service_Exception($body, $code, null, self::getResponseErrors($body));
     }
 
     // Ensure we only pull the entire body into memory if the request is not
@@ -123,60 +123,60 @@ 
     $body = self::decodeBody($response, $request);
 
     if ($expectedClass = self::determineExpectedClass($expectedClass, $request)) {
-      $json = json_decode($body, true);
+        $json = json_decode($body, true);
 
-      return new $expectedClass($json);
+        return new $expectedClass($json);
     }
 
     return $response;
-  }
+    }
 
-  private static function decodeBody(ResponseInterface $response, RequestInterface $request = null)
-  {
+    private static function decodeBody(ResponseInterface $response, RequestInterface $request = null)
+    {
     if (self::isAltMedia($request)) {
-      // don't decode the body, it's probably a really long string
-      return '';
+        // don't decode the body, it's probably a really long string
+        return '';
     }
 
     return (string) $response->getBody();
-  }
+    }
 
-  private static function determineExpectedClass($expectedClass, RequestInterface $request = null)
-  {
+    private static function determineExpectedClass($expectedClass, RequestInterface $request = null)
+    {
     // "false" is used to explicitly prevent an expected class from being returned
     if (false === $expectedClass) {
-      return null;
+        return null;
     }
 
     // if we don't have a request, we just use what's passed in
     if (null === $request) {
-      return $expectedClass;
+        return $expectedClass;
     }
 
     // return what we have in the request header if one was not supplied
     return $expectedClass ?: $request->getHeaderLine('X-Php-Expected-Class');
-  }
+    }
 
-  private static function getResponseErrors($body)
-  {
+    private static function getResponseErrors($body)
+    {
     $json = json_decode($body, true);
 
     if (isset($json['error']['errors'])) {
-      return $json['error']['errors'];
+        return $json['error']['errors'];
     }
 
     return null;
-  }
+    }
 
-  private static function isAltMedia(RequestInterface $request = null)
-  {
+    private static function isAltMedia(RequestInterface $request = null)
+    {
     if ($request && $qs = $request->getUri()->getQuery()) {
-      parse_str($qs, $query);
-      if (isset($query['alt']) && $query['alt'] == 'media') {
+        parse_str($qs, $query);
+        if (isset($query['alt']) && $query['alt'] == 'media') {
         return true;
-      }
+        }
     }
 
     return false;
-  }
+    }
 }

lib/Google/Http/MediaFileUpload.php

Indentation +203 added lines, -203 removed lines

@@ -26,61 +26,61 @@ 
  */
 class Google_Http_MediaFileUpload
 {
-  const UPLOAD_MEDIA_TYPE = 'media';
-  const UPLOAD_MULTIPART_TYPE = 'multipart';
-  const UPLOAD_RESUMABLE_TYPE = 'resumable';
-
-  /** @var string $mimeType */
-  private $mimeType;
-
-  /** @var string $data */
-  private $data;
-
-  /** @var bool $resumable */
-  private $resumable;
-
-  /** @var int $chunkSize */
-  private $chunkSize;
-
-  /** @var int $size */
-  private $size;
-
-  /** @var string $resumeUri */
-  private $resumeUri;
-
-  /** @var int $progress */
-  private $progress;
-
-  /** @var Google_Client */
-  private $client;
-
-  /** @var Psr\Http\Message\RequestInterface */
-  private $request;
-
-  /** @var string */
-  private $boundary;
-
-  /**
-   * Result code from last HTTP call
-   * @var int
-   */
-  private $httpResultCode;
-
-  /**
-   * @param $mimeType string
-   * @param $data string The bytes you want to upload.
-   * @param $resumable bool
-   * @param bool $chunkSize File will be uploaded in chunks of this many bytes.
-   * only used if resumable=True
-   */
-  public function __construct(
-      Google_Client $client,
-      RequestInterface $request,
-      $mimeType,
-      $data,
-      $resumable = false,
-      $chunkSize = false
-  ) {
+    const UPLOAD_MEDIA_TYPE = 'media';
+    const UPLOAD_MULTIPART_TYPE = 'multipart';
+    const UPLOAD_RESUMABLE_TYPE = 'resumable';
+
+    /** @var string $mimeType */
+    private $mimeType;
+
+    /** @var string $data */
+    private $data;
+
+    /** @var bool $resumable */
+    private $resumable;
+
+    /** @var int $chunkSize */
+    private $chunkSize;
+
+    /** @var int $size */
+    private $size;
+
+    /** @var string $resumeUri */
+    private $resumeUri;
+
+    /** @var int $progress */
+    private $progress;
+
+    /** @var Google_Client */
+    private $client;
+
+    /** @var Psr\Http\Message\RequestInterface */
+    private $request;
+
+    /** @var string */
+    private $boundary;
+
+    /**
+     * Result code from last HTTP call
+     * @var int
+     */
+    private $httpResultCode;
+
+    /**
+     * @param $mimeType string
+     * @param $data string The bytes you want to upload.
+     * @param $resumable bool
+     * @param bool $chunkSize File will be uploaded in chunks of this many bytes.
+     * only used if resumable=True
+     */
+    public function __construct(
+        Google_Client $client,
+        RequestInterface $request,
+        $mimeType,
+        $data,
+        $resumable = false,
+        $chunkSize = false
+    ) {
     $this->client = $client;
     $this->request = $request;
     $this->mimeType = $mimeType;
@@ -90,44 +90,44 @@ 
     $this->progress = 0;
 
     $this->process();
-  }
-
-  /**
-   * Set the size of the file that is being uploaded.
-   * @param $size - int file size in bytes
-   */
-  public function setFileSize($size)
-  {
+    }
+
+    /**
+     * Set the size of the file that is being uploaded.
+     * @param $size - int file size in bytes
+     */
+    public function setFileSize($size)
+    {
     $this->size = $size;
-  }
-
-  /**
-   * Return the progress on the upload
-   * @return int progress in bytes uploaded.
-   */
-  public function getProgress()
-  {
+    }
+
+    /**
+     * Return the progress on the upload
+     * @return int progress in bytes uploaded.
+     */
+    public function getProgress()
+    {
     return $this->progress;
-  }
-
-  /**
-   * Send the next part of the file to upload.
-   * @param [$chunk] the next set of bytes to send. If false will used $data passed
-   * at construct time.
-   */
-  public function nextChunk($chunk = false)
-  {
+    }
+
+    /**
+     * Send the next part of the file to upload.
+     * @param [$chunk] the next set of bytes to send. If false will used $data passed
+     * at construct time.
+     */
+    public function nextChunk($chunk = false)
+    {
     $resumeUri = $this->getResumeUri();
 
     if (false == $chunk) {
-      $chunk = substr($this->data, $this->progress, $this->chunkSize);
+        $chunk = substr($this->data, $this->progress, $this->chunkSize);
     }
 
     $lastBytePos = $this->progress + strlen($chunk) - 1;
     $headers = array(
-      'content-range' => "bytes $this->progress-$lastBytePos/$this->size",
-      'content-length' => strlen($chunk),
-      'expect' => '',
+        'content-range' => "bytes $this->progress-$lastBytePos/$this->size",
+        'content-length' => strlen($chunk),
+        'expect' => '',
     );
 
     $request = new Request(
@@ -138,78 +138,78 @@ 
     );
 
     return $this->makePutRequest($request);
-  }
-
-  /**
-   * Return the HTTP result code from the last call made.
-   * @return int code
-   */
-  public function getHttpResultCode()
-  {
+    }
+
+    /**
+     * Return the HTTP result code from the last call made.
+     * @return int code
+     */
+    public function getHttpResultCode()
+    {
     return $this->httpResultCode;
-  }
-
-  /**
-  * Sends a PUT-Request to google drive and parses the response,
-  * setting the appropiate variables from the response()
-  *
-  * @param Google_Http_Request $httpRequest the Reuqest which will be send
-  *
-  * @return false|mixed false when the upload is unfinished or the decoded http response
-  *
-  */
-  private function makePutRequest(RequestInterface $request)
-  {
+    }
+
+    /**
+     * Sends a PUT-Request to google drive and parses the response,
+     * setting the appropiate variables from the response()
+     *
+     * @param Google_Http_Request $httpRequest the Reuqest which will be send
+     *
+     * @return false|mixed false when the upload is unfinished or the decoded http response
+     *
+     */
+    private function makePutRequest(RequestInterface $request)
+    {
     $response = $this->client->execute($request);
     $this->httpResultCode = $response->getStatusCode();
 
     if (308 == $this->httpResultCode) {
-      // Track the amount uploaded.
-      $range = $response->getHeaderLine('range');
-      if ($range) {
+        // Track the amount uploaded.
+        $range = $response->getHeaderLine('range');
+        if ($range) {
         $range_array = explode('-', $range);
         $this->progress = $range_array[1] + 1;
-      }
+        }
 
-      // Allow for changing upload URLs.
-      $location = $response->getHeaderLine('location');
-      if ($location) {
+        // Allow for changing upload URLs.
+        $location = $response->getHeaderLine('location');
+        if ($location) {
         $this->resumeUri = $location;
-      }
+        }
 
-      // No problems, but upload not complete.
-      return false;
+        // No problems, but upload not complete.
+        return false;
     }
 
     return Google_Http_REST::decodeHttpResponse($response, $this->request);
-  }
-
-  /**
-   * Resume a previously unfinished upload
-   * @param $resumeUri the resume-URI of the unfinished, resumable upload.
-   */
-  public function resume($resumeUri)
-  {
-     $this->resumeUri = $resumeUri;
-     $headers = array(
-       'content-range' => "bytes */$this->size",
-       'content-length' => 0,
-     );
-     $httpRequest = new Request(
-         'PUT',
-         $this->resumeUri,
-         $headers
-     );
-
-     return $this->makePutRequest($httpRequest);
-  }
-
-  /**
-   * @return Psr\Http\Message\RequestInterface $request
-   * @visible for testing
-   */
-  private function process()
-  {
+    }
+
+    /**
+     * Resume a previously unfinished upload
+     * @param $resumeUri the resume-URI of the unfinished, resumable upload.
+     */
+    public function resume($resumeUri)
+    {
+        $this->resumeUri = $resumeUri;
+        $headers = array(
+        'content-range' => "bytes */$this->size",
+        'content-length' => 0,
+        );
+        $httpRequest = new Request(
+            'PUT',
+            $this->resumeUri,
+            $headers
+        );
+
+        return $this->makePutRequest($httpRequest);
+    }
+
+    /**
+     * @return Psr\Http\Message\RequestInterface $request
+     * @visible for testing
+     */
+    private function process()
+    {
     $this->transformToUploadUrl();
     $request = $this->request;
 
@@ -227,81 +227,81 @@ 
     $mimeType = $this->mimeType ?: $request->getHeaderLine('content-type');
 
     if (self::UPLOAD_RESUMABLE_TYPE == $uploadType) {
-      $contentType = $mimeType;
-      $postBody = is_string($meta) ? $meta : json_encode($meta);
+        $contentType = $mimeType;
+        $postBody = is_string($meta) ? $meta : json_encode($meta);
     } else if (self::UPLOAD_MEDIA_TYPE == $uploadType) {
-      $contentType = $mimeType;
-      $postBody = $this->data;
+        $contentType = $mimeType;
+        $postBody = $this->data;
     } else if (self::UPLOAD_MULTIPART_TYPE == $uploadType) {
-      // This is a multipart/related upload.
-      $boundary = $this->boundary ?: mt_rand();
-      $boundary = str_replace('"', '', $boundary);
-      $contentType = 'multipart/related; boundary=' . $boundary;
-      $related = "--$boundary\r\n";
-      $related .= "Content-Type: application/json; charset=UTF-8\r\n";
-      $related .= "\r\n" . json_encode($meta) . "\r\n";
-      $related .= "--$boundary\r\n";
-      $related .= "Content-Type: $mimeType\r\n";
-      $related .= "Content-Transfer-Encoding: base64\r\n";
-      $related .= "\r\n" . base64_encode($this->data) . "\r\n";
-      $related .= "--$boundary--";
-      $postBody = $related;
+        // This is a multipart/related upload.
+        $boundary = $this->boundary ?: mt_rand();
+        $boundary = str_replace('"', '', $boundary);
+        $contentType = 'multipart/related; boundary=' . $boundary;
+        $related = "--$boundary\r\n";
+        $related .= "Content-Type: application/json; charset=UTF-8\r\n";
+        $related .= "\r\n" . json_encode($meta) . "\r\n";
+        $related .= "--$boundary\r\n";
+        $related .= "Content-Type: $mimeType\r\n";
+        $related .= "Content-Transfer-Encoding: base64\r\n";
+        $related .= "\r\n" . base64_encode($this->data) . "\r\n";
+        $related .= "--$boundary--";
+        $postBody = $related;
     }
 
     $request = $request->withBody(Psr7\stream_for($postBody));
 
     if (isset($contentType) && $contentType) {
-      $request = $request->withHeader('content-type', $contentType);
+        $request = $request->withHeader('content-type', $contentType);
     }
 
     return $this->request = $request;
-  }
-
-  /**
-   * Valid upload types:
-   * - resumable (UPLOAD_RESUMABLE_TYPE)
-   * - media (UPLOAD_MEDIA_TYPE)
-   * - multipart (UPLOAD_MULTIPART_TYPE)
-   * @param $meta
-   * @return string
-   * @visible for testing
-   */
-  public function getUploadType($meta)
-  {
+    }
+
+    /**
+     * Valid upload types:
+     * - resumable (UPLOAD_RESUMABLE_TYPE)
+     * - media (UPLOAD_MEDIA_TYPE)
+     * - multipart (UPLOAD_MULTIPART_TYPE)
+     * @param $meta
+     * @return string
+     * @visible for testing
+     */
+    public function getUploadType($meta)
+    {
     if ($this->resumable) {
-      return self::UPLOAD_RESUMABLE_TYPE;
+        return self::UPLOAD_RESUMABLE_TYPE;
     }
 
     if (false == $meta && $this->data) {
-      return self::UPLOAD_MEDIA_TYPE;
+        return self::UPLOAD_MEDIA_TYPE;
     }
 
     return self::UPLOAD_MULTIPART_TYPE;
-  }
+    }
 
-  public function getResumeUri()
-  {
+    public function getResumeUri()
+    {
     if (null === $this->resumeUri) {
-      $this->resumeUri = $this->fetchResumeUri();
+        $this->resumeUri = $this->fetchResumeUri();
     }
 
     return $this->resumeUri;
-  }
+    }
 
-  private function fetchResumeUri()
-  {
+    private function fetchResumeUri()
+    {
     $body = $this->request->getBody();
     if ($body) {
-      $headers = array(
+        $headers = array(
         'content-type' => 'application/json; charset=UTF-8',
         'content-length' => $body->getSize(),
         'x-upload-content-type' => $this->mimeType,
         'x-upload-content-length' => $this->size,
         'expect' => '',
-      );
-      foreach ($headers as $key => $value) {
+        );
+        foreach ($headers as $key => $value) {
         $this->request = $this->request->withHeader($key, $value);
-      }
+        }
     }
 
     $response = $this->client->execute($this->request, false);
@@ -309,43 +309,43 @@ 
     $code = $response->getStatusCode();
 
     if (200 == $code && true == $location) {
-      return $location;
+        return $location;
     }
 
     $message = $code;
     $body = json_decode((string) $this->request->getBody(), true);
     if (isset($body['error']['errors'])) {
-      $message .= ': ';
-      foreach ($body['error']['errors'] as $error) {
+        $message .= ': ';
+        foreach ($body['error']['errors'] as $error) {
         $message .= "{$error['domain']}, {$error['message']};";
-      }
-      $message = rtrim($message, ';');
+        }
+        $message = rtrim($message, ';');
     }
 
     $error = "Failed to start the resumable upload (HTTP {$message})";
     $this->client->getLogger()->error($error);
 
     throw new Google_Exception($error);
-  }
+    }
 
-  private function transformToUploadUrl()
-  {
+    private function transformToUploadUrl()
+    {
     $parts = parse_url((string) $this->request->getUri());
     if (!isset($parts['path'])) {
-      $parts['path'] = '';
+        $parts['path'] = '';
     }
     $parts['path'] = '/upload' . $parts['path'];
     $uri = Uri::fromParts($parts);
     $this->request = $this->request->withUri($uri);
-  }
+    }
 
-  public function setChunkSize($chunkSize)
-  {
+    public function setChunkSize($chunkSize)
+    {
     $this->chunkSize = $chunkSize;
-  }
+    }
 
-  public function getRequest()
-  {
+    public function getRequest()
+    {
     return $this->request;
-  }
+    }
 }

lib/Google/Task/Runner.php

Indentation +162 added lines, -162 removed lines

@@ -22,52 +22,52 @@ 
  */
 class Google_Task_Runner
 {
-  const TASK_RETRY_NEVER = 0;
-  const TASK_RETRY_ONCE = 1;
-  const TASK_RETRY_ALWAYS = -1;
-
-  /**
-   * @var integer $maxDelay The max time (in seconds) to wait before a retry.
-   */
-  private $maxDelay = 60;
-  /**
-   * @var integer $delay The previous delay from which the next is calculated.
-   */
-  private $delay = 1;
-
-  /**
-   * @var integer $factor The base number for the exponential back off.
-   */
-  private $factor = 2;
-  /**
-   * @var float $jitter A random number between -$jitter and $jitter will be
-   * added to $factor on each iteration to allow for a better distribution of
-   * retries.
-   */
-  private $jitter = 0.5;
-
-  /**
-   * @var integer $attempts The number of attempts that have been tried so far.
-   */
-  private $attempts = 0;
-  /**
-   * @var integer $maxAttempts The max number of attempts allowed.
-   */
-  private $maxAttempts = 1;
-
-  /**
-   * @var callable $action The task to run and possibly retry.
-   */
-  private $action;
-  /**
-   * @var array $arguments The task arguments.
-   */
-  private $arguments;
-
-  /**
-   * @var array $retryMap Map of errors with retry counts.
-   */
-  protected $retryMap = [
+    const TASK_RETRY_NEVER = 0;
+    const TASK_RETRY_ONCE = 1;
+    const TASK_RETRY_ALWAYS = -1;
+
+    /**
+     * @var integer $maxDelay The max time (in seconds) to wait before a retry.
+     */
+    private $maxDelay = 60;
+    /**
+     * @var integer $delay The previous delay from which the next is calculated.
+     */
+    private $delay = 1;
+
+    /**
+     * @var integer $factor The base number for the exponential back off.
+     */
+    private $factor = 2;
+    /**
+     * @var float $jitter A random number between -$jitter and $jitter will be
+     * added to $factor on each iteration to allow for a better distribution of
+     * retries.
+     */
+    private $jitter = 0.5;
+
+    /**
+     * @var integer $attempts The number of attempts that have been tried so far.
+     */
+    private $attempts = 0;
+    /**
+     * @var integer $maxAttempts The max number of attempts allowed.
+     */
+    private $maxAttempts = 1;
+
+    /**
+     * @var callable $action The task to run and possibly retry.
+     */
+    private $action;
+    /**
+     * @var array $arguments The task arguments.
+     */
+    private $arguments;
+
+    /**
+     * @var array $retryMap Map of errors with retry counts.
+     */
+    protected $retryMap = [
     '500' => self::TASK_RETRY_ALWAYS,
     '503' => self::TASK_RETRY_ALWAYS,
     'rateLimitExceeded' => self::TASK_RETRY_ALWAYS,
@@ -77,70 +77,70 @@ 
     28 => self::TASK_RETRY_ALWAYS,  // CURLE_OPERATION_TIMEOUTED
     35 => self::TASK_RETRY_ALWAYS,  // CURLE_SSL_CONNECT_ERROR
     52 => self::TASK_RETRY_ALWAYS   // CURLE_GOT_NOTHING
-  ];
-
-  /**
-   * Creates a new task runner with exponential backoff support.
-   *
-   * @param array $config The task runner config
-   * @param string $name The name of the current task (used for logging)
-   * @param callable $action The task to run and possibly retry
-   * @param array $arguments The task arguments
-   * @throws Google_Task_Exception when misconfigured
-   */
-  public function __construct(
-      $config,
-      $name,
-      $action,
-      array $arguments = array()
-  ) {
+    ];
+
+    /**
+     * Creates a new task runner with exponential backoff support.
+     *
+     * @param array $config The task runner config
+     * @param string $name The name of the current task (used for logging)
+     * @param callable $action The task to run and possibly retry
+     * @param array $arguments The task arguments
+     * @throws Google_Task_Exception when misconfigured
+     */
+    public function __construct(
+        $config,
+        $name,
+        $action,
+        array $arguments = array()
+    ) {
     if (isset($config['initial_delay'])) {
-      if ($config['initial_delay'] < 0) {
+        if ($config['initial_delay'] < 0) {
         throw new Google_Task_Exception(
             'Task configuration `initial_delay` must not be negative.'
         );
-      }
+        }
 
-      $this->delay = $config['initial_delay'];
+        $this->delay = $config['initial_delay'];
     }
 
     if (isset($config['max_delay'])) {
-      if ($config['max_delay'] <= 0) {
+        if ($config['max_delay'] <= 0) {
         throw new Google_Task_Exception(
             'Task configuration `max_delay` must be greater than 0.'
         );
-      }
+        }
 
-      $this->maxDelay = $config['max_delay'];
+        $this->maxDelay = $config['max_delay'];
     }
 
     if (isset($config['factor'])) {
-      if ($config['factor'] <= 0) {
+        if ($config['factor'] <= 0) {
         throw new Google_Task_Exception(
             'Task configuration `factor` must be greater than 0.'
         );
-      }
+        }
 
-      $this->factor = $config['factor'];
+        $this->factor = $config['factor'];
     }
 
     if (isset($config['jitter'])) {
-      if ($config['jitter'] <= 0) {
+        if ($config['jitter'] <= 0) {
         throw new Google_Task_Exception(
             'Task configuration `jitter` must be greater than 0.'
         );
-      }
+        }
 
-      $this->jitter = $config['jitter'];
+        $this->jitter = $config['jitter'];
     }
 
     if (isset($config['retries'])) {
-      if ($config['retries'] < 0) {
+        if ($config['retries'] < 0) {
         throw new Google_Task_Exception(
             'Task configuration `retries` must not be negative.'
         );
-      }
-      $this->maxAttempts += $config['retries'];
+        }
+        $this->maxAttempts += $config['retries'];
     }
 
     if (!is_callable($action)) {
@@ -151,131 +151,131 @@ 
 
     $this->action = $action;
     $this->arguments = $arguments;
-  }
-
-  /**
-   * Checks if a retry can be attempted.
-   *
-   * @return boolean
-   */
-  public function canAttempt()
-  {
+    }
+
+    /**
+     * Checks if a retry can be attempted.
+     *
+     * @return boolean
+     */
+    public function canAttempt()
+    {
     return $this->attempts < $this->maxAttempts;
-  }
-
-  /**
-   * Runs the task and (if applicable) automatically retries when errors occur.
-   *
-   * @return mixed
-   * @throws Google_Task_Retryable on failure when no retries are available.
-   */
-  public function run()
-  {
+    }
+
+    /**
+     * Runs the task and (if applicable) automatically retries when errors occur.
+     *
+     * @return mixed
+     * @throws Google_Task_Retryable on failure when no retries are available.
+     */
+    public function run()
+    {
     while ($this->attempt()) {
-      try {
+        try {
         return call_user_func_array($this->action, $this->arguments);
-      } catch (Google_Service_Exception $exception) {
+        } catch (Google_Service_Exception $exception) {
         $allowedRetries = $this->allowedRetries(
             $exception->getCode(),
             $exception->getErrors()
         );
 
         if (!$this->canAttempt() || !$allowedRetries) {
-          throw $exception;
+            throw $exception;
         }
 
         if ($allowedRetries > 0) {
-          $this->maxAttempts = min(
-              $this->maxAttempts,
-              $this->attempts + $allowedRetries
-          );
+            $this->maxAttempts = min(
+                $this->maxAttempts,
+                $this->attempts + $allowedRetries
+            );
+        }
         }
-      }
     }
-  }
-
-  /**
-   * Runs a task once, if possible. This is useful for bypassing the `run()`
-   * loop.
-   *
-   * NOTE: If this is not the first attempt, this function will sleep in
-   * accordance to the backoff configurations before running the task.
-   *
-   * @return boolean
-   */
-  public function attempt()
-  {
+    }
+
+    /**
+     * Runs a task once, if possible. This is useful for bypassing the `run()`
+     * loop.
+     *
+     * NOTE: If this is not the first attempt, this function will sleep in
+     * accordance to the backoff configurations before running the task.
+     *
+     * @return boolean
+     */
+    public function attempt()
+    {
     if (!$this->canAttempt()) {
-      return false;
+        return false;
     }
 
     if ($this->attempts > 0) {
-      $this->backOff();
+        $this->backOff();
     }
 
     $this->attempts++;
     return true;
-  }
+    }
 
-  /**
-   * Sleeps in accordance to the backoff configurations.
-   */
-  private function backOff()
-  {
+    /**
+     * Sleeps in accordance to the backoff configurations.
+     */
+    private function backOff()
+    {
     $delay = $this->getDelay();
 
     usleep($delay * 1000000);
-  }
-
-  /**
-   * Gets the delay (in seconds) for the current backoff period.
-   *
-   * @return float
-   */
-  private function getDelay()
-  {
+    }
+
+    /**
+     * Gets the delay (in seconds) for the current backoff period.
+     *
+     * @return float
+     */
+    private function getDelay()
+    {
     $jitter = $this->getJitter();
     $factor = $this->attempts > 1 ? $this->factor + $jitter : 1 + abs($jitter);
 
     return $this->delay = min($this->maxDelay, $this->delay * $factor);
-  }
-
-  /**
-   * Gets the current jitter (random number between -$this->jitter and
-   * $this->jitter).
-   *
-   * @return float
-   */
-  private function getJitter()
-  {
+    }
+
+    /**
+     * Gets the current jitter (random number between -$this->jitter and
+     * $this->jitter).
+     *
+     * @return float
+     */
+    private function getJitter()
+    {
     return $this->jitter * 2 * mt_rand() / mt_getrandmax() - $this->jitter;
-  }
-
-  /**
-   * Gets the number of times the associated task can be retried.
-   *
-   * NOTE: -1 is returned if the task can be retried indefinitely
-   *
-   * @return integer
-   */
-  public function allowedRetries($code, $errors = array())
-  {
+    }
+
+    /**
+     * Gets the number of times the associated task can be retried.
+     *
+     * NOTE: -1 is returned if the task can be retried indefinitely
+     *
+     * @return integer
+     */
+    public function allowedRetries($code, $errors = array())
+    {
     if (isset($this->retryMap[$code])) {
-      return $this->retryMap[$code];
+        return $this->retryMap[$code];
     }
 
     if (
         !empty($errors) &&
         isset($errors[0]['reason'], $this->retryMap[$errors[0]['reason']])
     ) {
-      return $this->retryMap[$errors[0]['reason']];
+        return $this->retryMap[$errors[0]['reason']];
     }
 
     return 0;
-  }
+    }
 
-  public function setRetryMap($retryMap)
-  {
+    public function setRetryMap($retryMap)
+    {
     $this->retryMap = $retryMap;
-  }
+    }
 }

lib/move_to_picasa.php

Indentation +76 added lines, -76 removed lines

@@ -5,10 +5,10 @@ 
 //============  Google Move Code ======================//
 
 if ( isset( $_GET['album_download_directory'] ) ) {
-	$album_download_directory = $_GET['album_download_directory'];
-	$album_download_directory = '../'.$album_download_directory;
+    $album_download_directory = $_GET['album_download_directory'];
+    $album_download_directory = '../'.$album_download_directory;
 } else {
-	header('location:../index.php');
+    header('location:../index.php');
 }
 
 require_once 'Zend/autooad.php';
@@ -18,10 +18,10 @@ 
 
 
 function getAuthSubHttpClient() {
-	if ( isset( $_SESSION['google_session_token'] ) ) {
-		$client = Zend_Gdata_AuthSub::getHttpClient( $_SESSION['google_session_token'] );
-		return $client;
-	}
+    if ( isset( $_SESSION['google_session_token'] ) ) {
+        $client = Zend_Gdata_AuthSub::getHttpClient( $_SESSION['google_session_token'] );
+        return $client;
+    }
 }
 
 $gp = new Zend_Gdata_Photos(getAuthSubHttpClient(), "Google-DevelopersGuide-1.0");
@@ -29,87 +29,87 @@ 
 
 
 function add_new_album( $entry, $gp, $album_download_directory, $album_name ) {
-	$new_album_name = str_replace( " ", "_", $album_name );
-	$new_album_name = $new_album_name.'_'.uniqid();
-
-	$entry->setTitle( $gp->newTitle( $new_album_name ) );
-	$entry->setSummary( $gp->newSummary("Album added by Facebook Album Challenge") );
-	$gp->insertAlbumEntry( $entry );
-
-	$path = $album_download_directory.$album_name;
-	if ( file_exists( $path ) ) {
-		$photos = scandir( $path );
-
-		foreach ( $photos as $photo ) {
-			if ( $photo != "." && $photo != ".." ) {
-				$photo_path = $path.'/'.$photo;
-				add_new_photo_to_album( $gp, $photo_path, $new_album_name );
-			}
-		}
-	}	
+    $new_album_name = str_replace( " ", "_", $album_name );
+    $new_album_name = $new_album_name.'_'.uniqid();
+
+    $entry->setTitle( $gp->newTitle( $new_album_name ) );
+    $entry->setSummary( $gp->newSummary("Album added by Facebook Album Challenge") );
+    $gp->insertAlbumEntry( $entry );
+
+    $path = $album_download_directory.$album_name;
+    if ( file_exists( $path ) ) {
+        $photos = scandir( $path );
+
+        foreach ( $photos as $photo ) {
+            if ( $photo != "." && $photo != ".." ) {
+                $photo_path = $path.'/'.$photo;
+                add_new_photo_to_album( $gp, $photo_path, $new_album_name );
+            }
+        }
+    }	
 }
 
 function add_new_photo_to_album( $gp, $path, $new_album_name ) {
-	$user_name = "default";
-	$file_name = $path;
-	$photo_name = "Photo added by Facebook Album Challenge";
-	$photo_caption = "Photo added by Facebook Album Challenge";
-	$photo_tags = "Photo, Facebook-Album-Challenge";
-
-	$fd = $gp->newMediaFileSource( $file_name );
-	$fd->setContentType("image/jpeg");
-
-	// Create a PhotoEntry
-	$photo_entry = $gp->newPhotoEntry();
-
-	$photo_entry->setMediaSource( $fd );
-	$photo_entry->setTitle( $gp->newTitle( $photo_name ) );
-	$photo_entry->setSummary( $gp->newSummary( $photo_caption ) );
-
-	// add some tags
-	$photo_media = new Zend_Gdata_Media_Extension_MediaKeywords();
-	$photo_media->setText( $photo_tags );
-	$photo_entry->mediaGroup = new Zend_Gdata_Media_Extension_MediaGroup();
-	$photo_entry->mediaGroup->keywords = $photo_media;
-
-	// We use the AlbumQuery class to generate the URL for the album
-	$album_query = $gp->newAlbumQuery();
-
-	$album_query->setUser( $user_name );
-	//$albumQuery->setAlbumId($albumId);
-	$album_query->setAlbumName( $new_album_name );
-
-	// We insert the photo, and the server returns the entry representing
-	// that photo after it is uploaded
-	//$insertedEntry = $gp->insertPhotoEntry( $photoEntry, $albumQuery->getQueryUrl() );
-	$gp->insertPhotoEntry( $photo_entry, $album_query->getQueryUrl() );
+    $user_name = "default";
+    $file_name = $path;
+    $photo_name = "Photo added by Facebook Album Challenge";
+    $photo_caption = "Photo added by Facebook Album Challenge";
+    $photo_tags = "Photo, Facebook-Album-Challenge";
+
+    $fd = $gp->newMediaFileSource( $file_name );
+    $fd->setContentType("image/jpeg");
+
+    // Create a PhotoEntry
+    $photo_entry = $gp->newPhotoEntry();
+
+    $photo_entry->setMediaSource( $fd );
+    $photo_entry->setTitle( $gp->newTitle( $photo_name ) );
+    $photo_entry->setSummary( $gp->newSummary( $photo_caption ) );
+
+    // add some tags
+    $photo_media = new Zend_Gdata_Media_Extension_MediaKeywords();
+    $photo_media->setText( $photo_tags );
+    $photo_entry->mediaGroup = new Zend_Gdata_Media_Extension_MediaGroup();
+    $photo_entry->mediaGroup->keywords = $photo_media;
+
+    // We use the AlbumQuery class to generate the URL for the album
+    $album_query = $gp->newAlbumQuery();
+
+    $album_query->setUser( $user_name );
+    //$albumQuery->setAlbumId($albumId);
+    $album_query->setAlbumName( $new_album_name );
+
+    // We insert the photo, and the server returns the entry representing
+    // that photo after it is uploaded
+    //$insertedEntry = $gp->insertPhotoEntry( $photoEntry, $albumQuery->getQueryUrl() );
+    $gp->insertPhotoEntry( $photo_entry, $album_query->getQueryUrl() );
 }
 
 if ( isset( $album_download_directory ) ) {
-	if ( file_exists( $album_download_directory ) ) {
-		$album_names = scandir( $album_download_directory );
-
-		foreach ( $album_names as $album_name ) {
-			if ( $album_name != "." && $album_name != "..") {
-				add_new_album( $entry, $gp, $album_download_directory, $album_name );
-			}
-		}
-
-		$unlink_folder = rtrim( $album_download_directory, "/" );
-		require_once('../unlink_directory.php');
-		$unlink_directory = new unlink_directory();
-		$unlink_directory->remove_directory( $unlink_folder );
-	}
-	$response = 1;
+    if ( file_exists( $album_download_directory ) ) {
+        $album_names = scandir( $album_download_directory );
+
+        foreach ( $album_names as $album_name ) {
+            if ( $album_name != "." && $album_name != "..") {
+                add_new_album( $entry, $gp, $album_download_directory, $album_name );
+            }
+        }
+
+        $unlink_folder = rtrim( $album_download_directory, "/" );
+        require_once('../unlink_directory.php');
+        $unlink_directory = new unlink_directory();
+        $unlink_directory->remove_directory( $unlink_folder );
+    }
+    $response = 1;
 } else {
-	$response = 0;
+    $response = 0;
 }
 
 
 if ( isset( $_GET['ajax'] ) )
-	echo $response;
+    echo $response;
 else
-	header('location:../index.php?response='.$response);
+    header('location:../index.php?response='.$response);
 
 
 ?>

member.php

Indentation +11 added lines, -11 removed lines

@@ -141,20 +141,20 @@
             $cover_photo_id = isset($data['cover_photo']['id']) ? $data['cover_photo']['id'] : '';
             $count = isset($data['count']) ? $data['count'] : '';
           
-          $pictureLink = "slideshow.php?album_id={$id}&album_name={$name}";
-          echo "<div class='carding'>";
-          echo "<a target='_blank' href='{$pictureLink}'>";
-          $cover_photo_id = (!empty($cover_photo_id))?$cover_photo_id : 123456;
-          echo "<img width=200px height=200px src='https://graph.facebook.com/v3.3/{$cover_photo_id}/picture?access_token={$accessToken}' alt=''>";
-          echo "<p>{$name}</p>";
-          echo "</a>";
-          //echo "$images";
+            $pictureLink = "slideshow.php?album_id={$id}&album_name={$name}";
+            echo "<div class='carding'>";
+            echo "<a target='_blank' href='{$pictureLink}'>";
+            $cover_photo_id = (!empty($cover_photo_id))?$cover_photo_id : 123456;
+            echo "<img width=200px height=200px src='https://graph.facebook.com/v3.3/{$cover_photo_id}/picture?access_token={$accessToken}' alt=''>";
+            echo "<p>{$name}</p>";
+            echo "</a>";
+            //echo "$images";
           
             $photoCount = ($count > 1) ? $count . 'Photos' : $count . 'Photo';
           
-          echo "<p><span style='color:#888;'>{$photoCount} / <a href='{$link}' target='_blank'>View on Facebook</a></span></p>";
-          echo "<p>{$description}</p>";
-          ?>
+            echo "<p><span style='color:#888;'>{$photoCount} / <a href='{$link}' target='_blank'>View on Facebook</a></span></p>";
+            echo "<p>{$description}</p>";
+            ?>
 		<div class="caption">
 		  
 			<button rel="<?php echo $id.','.$name;?>" class="single-download btn btn-primary pull-left" title="Download Album">

functions.php

Indentation +31 added lines, -31 removed lines

@@ -1,20 +1,20 @@ 
 <?php
 session_start();
 ini_set('max_execution_time', 300);
-	require_once 'appconfig.php';
+    require_once 'appconfig.php';
 
-		use Facebook\GraphNodes\GraphObject;
-		use Facebook\GraphNodes\GraphSessionInfo;
-		use Facebook\Authentication\AccessToken;
-		use Facebook\HttpClients\FacebookHttpable;
-		use Facebook\HttpClients\FacebookCurl;
-		use Facebook\HttpClients\FacebookCurlHttpClient;
-		use Facebook\FacebookSession;
-		use Facebook\Helpers\FacebookRedirectLoginHelper;
-		use Facebook\FacebookRequest;
-		use Facebook\FacebookResponse;
-		use Facebook\Exceptions\FacebookSDKException;
-		use Facebook\Exceptions\FacebookAuthorizationException;
+        use Facebook\GraphNodes\GraphObject;
+        use Facebook\GraphNodes\GraphSessionInfo;
+        use Facebook\Authentication\AccessToken;
+        use Facebook\HttpClients\FacebookHttpable;
+        use Facebook\HttpClients\FacebookCurl;
+        use Facebook\HttpClients\FacebookCurlHttpClient;
+        use Facebook\FacebookSession;
+        use Facebook\Helpers\FacebookRedirectLoginHelper;
+        use Facebook\FacebookRequest;
+        use Facebook\FacebookResponse;
+        use Facebook\Exceptions\FacebookSDKException;
+        use Facebook\Exceptions\FacebookAuthorizationException;
 
     $session = $_SESSION['fb_access_token'];
 
@@ -24,25 +24,25 @@ 
 
     function download_album($session, $album_download_directory, $album_id, $album_name) {
 
-		$request_album_photos = "https://graph.facebook.com/v3.3/{$album_id}/photos?fields=source,images,name&limit=500&access_token={$session}";
-		$response_album_photos = file_get_contents($request_album_photos);			
-		$album_photos = json_decode($response_album_photos, true, 512, JSON_BIGINT_AS_STRING);
+        $request_album_photos = "https://graph.facebook.com/v3.3/{$album_id}/photos?fields=source,images,name&limit=500&access_token={$session}";
+        $response_album_photos = file_get_contents($request_album_photos);			
+        $album_photos = json_decode($response_album_photos, true, 512, JSON_BIGINT_AS_STRING);
 
-		$album_directory = $album_download_directory.$album_name;
-		if ( !file_exists( $album_directory ) ) {
-			mkdir($album_directory, 0777);
-		}
+        $album_directory = $album_download_directory.$album_name;
+        if ( !file_exists( $album_directory ) ) {
+            mkdir($album_directory, 0777);
+        }
 		
-		$i = 1;
-		foreach ( $album_photos['data'] as $album_photo ) {
-			$album_photo = (array) $album_photo;
-			file_put_contents( $album_directory.'/'.$i.".jpg", fopen( $album_photo['source'], 'r') );
-			$i++;
-		}
-	}
+        $i = 1;
+        foreach ( $album_photos['data'] as $album_photo ) {
+            $album_photo = (array) $album_photo;
+            file_put_contents( $album_directory.'/'.$i.".jpg", fopen( $album_photo['source'], 'r') );
+            $i++;
+        }
+    }
 
-	//---------- For 1 album download -------------------------------------------------//
-	if ( isset( $_GET['single_album'] ) && !empty ( $_GET['single_album'] ) ) {
+    //---------- For 1 album download -------------------------------------------------//
+    if ( isset( $_GET['single_album'] ) && !empty ( $_GET['single_album'] ) ) {
         
         $single_album = explode(",", $_GET['single_album']);
         download_album($session, $album_download_directory, $single_album[0], $single_album[1]);
@@ -64,8 +64,8 @@ 
 
             // graph api request for user data
 			
-			$request_albums = "https://graph.facebook.com/v3.3/me/albums?fields=id,name&access_token={$session}";
-			$response_albums = file_get_contents($request_albums);
+            $request_albums = "https://graph.facebook.com/v3.3/me/albums?fields=id,name&access_token={$session}";
+            $response_albums = file_get_contents($request_albums);
 			
             // get response
             $albums = json_decode($response_albums, true, 512, JSON_BIGINT_AS_STRING);