├── src
    ├── config
    │   └── laravel-firebase.php
    ├── HttpHandler
    │   ├── FirebaseInterface.php
    │   ├── HttpHandlerFactory.php
    │   ├── Guzzle5HttpHandler.php
    │   └── Guzzle6HttpHandler.php
    ├── Provider
    │   └── FirebaseServiceProvider.php
    ├── Subscribers
    │   └── EnsureJson.php
    ├── GoogleConsole.php
    ├── Middleware
    │   └── EnsureJson.php
    └── Firebase.php
├── .idea
    └── vcs.xml
├── tests
    ├── unit
    │   └── SampleTest.php
    └── _env
    │   └── ServiceAccount.json
├── phpunit.xml
├── composer.json
└── README.md


/src/config/laravel-firebase.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 |     return [
4 | 
5 |         'secretPath' => storage_path('app/secret_file.json')
6 |         
7 |     ];


--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="$PROJECT_DIR$" vcs="Git" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/tests/unit/SampleTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | 
 5 | class SampleTest extends \PHPUnit\Framework\TestCase {
 6 | 
 7 | 	public function testTrueAssertTrue() {
 8 | 
 9 | 		$this->assertTrue(true);
10 | 	}
11 | 
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/src/HttpHandler/FirebaseInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Geckob\Firebase\HttpHandler;
 4 | 
 5 | interface FirebaseInterface
 6 | {
 7 |     public function set($key, $value);
 8 | 
 9 |     public function get($key);
10 | 
11 |     public function delete($key);
12 | 
13 |     public function push($arr);
14 | }


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | 
 3 | <phpunit
 4 | 	bootstrap="vendor/autoload.php"
 5 | 	colors="true"
 6 | 	verbose="true"
 7 | 	stopOnFailure="false"
 8 | 	>
 9 | 
10 | 	<testsuites>
11 | 		<testsuite name="Test suite">
12 | 			<directory>tests</directory>
13 | 		</testsuite>
14 | 	</testsuites>
15 | 	
16 | </phpunit>


--------------------------------------------------------------------------------
/src/Provider/FirebaseServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Geckob\Firebase\Provider;
 4 | 
 5 | use Illuminate\Support\ServiceProvider;
 6 | 
 7 | 
 8 | class FirebaseServiceProvider extends ServiceProvider
 9 | {
10 | 
11 |     public function boot() {
12 | 
13 |         $this->publishes([
14 |             __DIR__.'/../config/laravel-firebase.php' => config_path('laravel-firebase.php'),
15 |         ], 'config');
16 | 
17 |     }
18 | 
19 |     public function register() {
20 | 
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/src/Subscribers/EnsureJson.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Geckob\Firebase\Subscribers;
 4 | 
 5 | use GuzzleHttp\Event\BeforeEvent;
 6 | use GuzzleHttp\Event\RequestEvents;
 7 | use GuzzleHttp\Event\SubscriberInterface;
 8 | 
 9 | class EnsureJson implements SubscriberInterface
10 | {
11 | 
12 |     public static function onBefore(BeforeEvent $event)
13 |     {
14 |         $request = $event->getRequest();
15 |     }
16 | 
17 |     /**
18 |      * @return array
19 |      */
20 |     public function getEvents()
21 |     {
22 |         return ['before' => ['onBefore', RequestEvents::SIGN_REQUEST]];
23 |     }
24 | 
25 | }


--------------------------------------------------------------------------------
/tests/_env/ServiceAccount.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "type": "service_account",
 3 |     "project_id": "project",
 4 |     "private_key_id": "private_key_id",
 5 |     "private_key": "-----BEGIN PRIVATE KEY-----ADD KEY HERE-----END PRIVATE KEY-----\n",
 6 |     "client_email": "client@email.tld",
 7 |     "client_id": "1234567890",
 8 |     "auth_uri": "https://some.google.tld/o/oauth2/auth",
 9 |     "token_uri": "https://some.google.tld/o/oauth2/token",
10 |     "auth_provider_x509_cert_url": "https://some.google.tld/oauth2/v1/certs",
11 |     "client_x509_cert_url": "https://some.google.tld/robot/v1/metadata/x509/user%40project.iam.gserviceaccount.com"
12 | }
13 | 


--------------------------------------------------------------------------------
/src/HttpHandler/HttpHandlerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Geckob\Firebase\HttpHandler;
 4 | 
 5 | use Geckob\Firebase\GoogleConsole;
 6 | use GuzzleHttp\ClientInterface;
 7 | 
 8 | 
 9 | class HttpHandlerFactory
10 | {
11 | 
12 |     public static function setup($config, $path, GoogleConsole $googleConsole)
13 |     {
14 |         $version = ClientInterface::VERSION;
15 | 
16 |         switch ($version[0]) {
17 |             case '5':
18 |                 return new Guzzle5HttpHandler($config, $googleConsole);
19 |             case '6':
20 |                 return new Guzzle6HttpHandler($config, $googleConsole);
21 |             default:
22 |                 throw new \Exception('Version not supported');
23 |         }
24 |     }
25 | 
26 | 
27 | 
28 | }


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "geckob/firebase",
 3 |     "description": "PHP package for Firebase wrapper",
 4 |     "license": "MIT",
 5 |     "keywords" : [
 6 |         "firebase",
 7 |         "firebase laravel",
 8 |         "firebase php",
 9 |         "google"
10 |     ],
11 |     "require": {
12 |         "google/auth": "^1.2",
13 |         "php": ">=5.3.0",
14 |         "guzzlehttp/guzzle": "~5.3|~6.0",
15 |         "guzzlehttp/psr7": "~1.2",
16 |         "illuminate/support": "^5.2.8"
17 | 
18 |     },
19 |     "authors": [
20 |         {
21 |             "name": "Luqman",
22 |             "email": "luqmanrom@gmail.com"
23 |         }
24 |     ],
25 |     "autoload": {
26 |         "psr-4": {
27 |             "Geckob\\Firebase\\": "src"
28 |         }
29 |     },
30 |     "require-dev": {
31 |         "phpunit/phpunit": "^6"
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/GoogleConsole.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Geckob\Firebase;
 4 | 
 5 | 
 6 | class GoogleConsole
 7 | {
 8 |     protected $scopes;
 9 | 
10 |     protected $credentials;
11 | 
12 |     public function __construct($config)
13 |     {
14 |         $this->scopes = [
15 |             'https://www.googleapis.com/auth/userinfo.email',
16 |             'https://www.googleapis.com/auth/firebase.database',
17 |         ];
18 | 
19 |         $this->credentials = [
20 |             'client_email' => $config['client_email'],
21 |             'client_id' => $config['client_id'],
22 |             'private_key' => $config['private_key'],
23 |         ];
24 |     }
25 | 
26 |     public function getCredentials()
27 |     {
28 |         return $this->credentials;
29 |     }
30 | 
31 |     public function getScopes()
32 |     {
33 |         return $this->scopes;
34 |     }
35 | 
36 | }


--------------------------------------------------------------------------------
/src/Middleware/EnsureJson.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Geckob\Firebase\Middleware;
 4 | 
 5 | use Psr\Http\Message\RequestInterface;
 6 | 
 7 | 
 8 | class EnsureJson
 9 | {
10 |     public static function run()
11 |     {
12 |         return function (callable $handler) {
13 |             return function (RequestInterface $request, array $options = []) use ($handler) {
14 |                 $uri = $request->getUri();
15 |                 $path = $uri->getPath();
16 | 
17 |                 if (substr($path, -5) !== '.json') {
18 |                     $uri = $uri->withPath($path.'.json');
19 |                     $request = $request->withUri($uri);
20 |                 }
21 | 
22 |                 $request = $request->withHeader('Content-Type', 'application/json');
23 | 
24 |                 return $handler($request, $options);
25 |             };
26 |         };
27 |     }
28 | 
29 | 
30 | 
31 | }


--------------------------------------------------------------------------------
/src/Firebase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Geckob\Firebase;
 4 | 
 5 | use Geckob\Firebase\HttpHandler\HttpHandlerFactory;
 6 | use GuzzleHttp\Psr7\Uri;
 7 | use GuzzleHttp\Client;
 8 | 
 9 | class Firebase
10 | {
11 |     protected $config;
12 | 
13 |     protected $httpClient;
14 | 
15 |     protected $path;
16 | 
17 |     public function __construct($secretFilePath = null, $config = ['timeout' => 0])
18 |     {
19 |         if (func_num_args() == 0) {
20 |             $secretFilePath = config('laravel-firebase.secretPath');
21 |         }
22 | 
23 |         $this->config = array_merge($this->extractSecrets($secretFilePath), $config);
24 | 
25 |         $googleConsole = new GoogleConsole($this->config);
26 | 
27 |         $this->httpClient = HttpHandlerFactory::setup($this->config, $this->path, $googleConsole);
28 | 
29 |     }
30 | 
31 |     private function extractSecrets($secretFilePath)
32 |     {
33 |         $config = file_get_contents($secretFilePath);
34 |         return json_decode($config, true);
35 |     }
36 | 
37 |     public function setPath($path)
38 |     {
39 |         $this->path = $path;
40 | 
41 |         $this->httpClient->setPath($path);
42 | 
43 |         return $this;
44 |     }
45 | 
46 | 
47 |     public function set($key, $value)
48 |     {
49 |         $this->httpClient->set($key, $value);
50 |     }
51 | 
52 |     public function get($key)
53 |     {
54 |         return $this->httpClient->get($key);
55 |     }
56 | 
57 |     public function delete($key)
58 |     {
59 |         $this->httpClient->delete($key);
60 |     }
61 | 
62 |     public function push($arr)
63 |     {
64 |         $this->httpClient->push($arr);
65 |     }
66 | 
67 | 
68 | }


--------------------------------------------------------------------------------
/src/HttpHandler/Guzzle5HttpHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Geckob\Firebase\HttpHandler;
 4 | 
 5 | use Geckob\Firebase\GoogleConsole;
 6 | use Google\Auth\Subscriber\AuthTokenSubscriber;
 7 | use GuzzleHttp\Client;
 8 | use Google\Auth\Credentials\ServiceAccountCredentials;
 9 | use GuzzleHttp\Event\Emitter;
10 | use GuzzleHttp\Event\BeforeEvent;
11 | 
12 | 
13 | class Guzzle5HttpHandler implements FirebaseInterface
14 | {
15 |     protected $config;
16 | 
17 |     protected $databaseUri;
18 | 
19 |     protected $http;
20 | 
21 |     protected $path;
22 | 
23 |     public function __construct($config, GoogleConsole $googleConsole)
24 |     {
25 |         $this->config = $config;
26 | 
27 |         $this->databaseUri = sprintf('https://%s.firebaseio.com/', $this->config['project_id']);
28 | 
29 |         $this->http = new Client([
30 |             'base_url' => $this->databaseUri,
31 |             'defaults' => [
32 |                 'auth' => 'google_auth'
33 |             ]
34 |         ]);
35 | 
36 |         $this->http->getEmitter()->attach(new AuthTokenSubscriber(
37 |             new ServiceAccountCredentials(
38 |                 $googleConsole->getScopes(),
39 |                 $googleConsole->getCredentials()
40 |             )));
41 |     }
42 | 
43 |     public function setPath($path)
44 |     {
45 |         $this->path = $path;
46 |     }
47 | 
48 |     public function set($key, $value)
49 |     {
50 |         $response = $this->http->put($this->path . $key . '.json', 
51 |             ['body' => json_encode($value), 'timeout' => $this->config['timeout']]);
52 | 
53 |         return (string) $response->getBody();
54 | 
55 |     }
56 | 
57 |     public function get($key)
58 |     {
59 |         $response = $this->http->get($this->path. $key . '.json',  ['timeout' => $this->config['timeout']]);
60 | 
61 |         return (string) $response->getBody();
62 | 
63 | 
64 |     }
65 | 
66 |     public function delete($key)
67 |     {
68 |         $response = $this->http->delete($this->path. $key . '.json',  ['timeout' => $this->config['timeout']]);
69 | 
70 |         return (string) $response->getBody();
71 |     }
72 | 
73 |     public function push($arr)
74 |     {
75 |         $response = $this->http->post($this->path . '.json', 
76 |             ['body' => json_encode($arr), 'timeout' => $this->config['timeout']]);
77 | 
78 |         return (string) $response->getBody();
79 |     }
80 | 
81 | }


--------------------------------------------------------------------------------
/src/HttpHandler/Guzzle6HttpHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Geckob\Firebase\HttpHandler;
 4 | 
 5 | use Geckob\Firebase\GoogleConsole;
 6 | use GuzzleHttp\Client;
 7 | use GuzzleHttp\HandlerStack;
 8 | use Google\Auth\Credentials\ServiceAccountCredentials;
 9 | use Google\Auth\Middleware\AuthTokenMiddleware;
10 | use Geckob\Firebase\Middleware\EnsureJson;
11 | use GuzzleHttp\Psr7\Uri;
12 | 
13 | class Guzzle6HttpHandler implements FirebaseInterface
14 | {
15 | 
16 |     protected $config;
17 | 
18 |     protected $databaseUri;
19 | 
20 |     protected $http;
21 | 
22 |     protected $path;
23 | 
24 |     public function __construct($config, GoogleConsole $googleConsole)
25 |     {
26 | 
27 |         $this->config = $config;
28 | 
29 |         $this->databaseUri = new Uri(sprintf('https://%s.firebaseio.com', $this->config['project_id']));
30 | 
31 |         $googleAuthTokenMiddleware = new AuthTokenMiddleware(
32 |             new ServiceAccountCredentials(
33 |                 $googleConsole->getScopes(),
34 |                 $googleConsole->getCredentials()
35 |             ));
36 | 
37 |         $stack = HandlerStack::create();
38 |         $stack->push(EnsureJson::run(), 'ensure_json');
39 |         $stack->push($googleAuthTokenMiddleware, 'auth_service_account');
40 | 
41 |         $this->http = new Client([
42 |             'base_uri' => $this->databaseUri,
43 |             'handler' => $stack,
44 |             'auth' => 'google_auth',
45 |         ]);
46 | 
47 |     }
48 | 
49 |     public function setPath($path) {
50 |         $this->path = $path;
51 |     }
52 | 
53 |     public function set($key, $value)
54 |     {
55 | 
56 |         $response = $this->http->request('PUT', $this->databaseUri->withPath($this->path.$key),
57 |             ['body' => json_encode($value), 'timeout' => $this->config['timeout']]
58 |         );
59 | 
60 |         return $response->getBody()->getContents();
61 | 
62 | 
63 |     }
64 | 
65 |     public function get($key)
66 |     {
67 | 
68 |         $response = $this->http->request('GET', $this->databaseUri->withPath($this->path. $key,
69 |             ['timeout' => $this->config['timeout']]));
70 | 
71 |         return $response->getBody()->getContents();
72 | 
73 |     }
74 | 
75 |     public function delete($key)
76 |     {
77 |         $response = $this->http->request('DELETE', $this->databaseUri->withPath($this->path. $key,
78 |             ['timeout' => $this->config['timeout']]));
79 | 
80 |         return $response->getBody()->getContents();
81 |     }
82 | 
83 |     public function push($arr)
84 |     {
85 |         $response = $this->http->request('POST', $this->databaseUri->withPath($this->path),
86 |             ['body' => json_encode($arr), 'timeout' => $this->config['timeout']]);
87 | 
88 |         return $response->getBody()->getContents();
89 |     }
90 | 
91 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Firebase PHP Wrapper
  2 | 
  3 | 
  4 | [![Packagist](https://img.shields.io/packagist/dt/geckob/firebase.svg)](https://packagist.org/packages/geckob/firebase)
  5 | 
  6 | 
  7 | This package makes the authentication and the basic CRUD
  8 | operation on Firebase Database as simple as possible. 
  9 | For now, it supports both Guzzle 5 and Guzzle 6. 
 10 | 
 11 | 
 12 | ## Installation
 13 | 
 14 | The easiest way it via Composer
 15 | 
 16 | ```
 17 | composer require geckob/firebase
 18 | ```
 19 | 
 20 | ## Usages
 21 | 
 22 | 
 23 | ### 1. Authentication
 24 | 
 25 | **1.1 Generate Service Account secret file**
 26 | 
 27 | This package supported authentication using secrets file generated in the Service Account page.
 28 | 
 29 | To generate the secret file, follow this steps
 30 | 
 31 | 1. Go to [Firebase Console](https://console.firebase.google.com/)
 32 | 2. Choose your project
 33 | 3. Click the gear icon and go to Project Settings
 34 | 4. Click the Service Accounts tab
 35 | 5. Scroll down and click "Generate New Private Key" button. Save it to somewhere secure but 
 36 | 	accessible for your internal server
 37 | 
 38 | **1.2 Use the secret file to authenticate**
 39 | 
 40 | ```php
 41 |     $firebase = new \Geckob\Firebase\Firebase('path_to_your_secret_file.json');
 42 | ```
 43 | ### 2. CRUD Operation
 44 | 
 45 | The CRUD operation on Firebase Database is based on the [Firebase REST API Docs](https://www.firebase.com/docs/rest-api.html).
 46 | 
 47 | Assuming the authentication is succesfully done,
 48 | 
 49 | ```php
 50 | // Set the parent node. 
 51 | $firebase = $firebase->setPath('bookings/');
 52 | 
 53 | // Create a new node with key = test and value = testValue. 
 54 | // If the node already exist, it will update the value
 55 | $firebase->set('test','testValue');
 56 | 
 57 | // Support multiple nodes, if it doesnt exist, it will create the node
 58 | $firebase->set('testObject/testKey', 'testValueObject');
 59 | 
 60 | 
 61 | // Same as set but without keys. This requires to call setPath first to identify the parent
 62 | $firebase->push([
 63 | 	'test'  => 'value',
 64 | 	'test1' => 'value1'
 65 | ]);
 66 | 
 67 | // Get the value of node with key = test
 68 | $firebase->get('test');
 69 | 
 70 | // Get the value of using multilevel key
 71 | $firebase->get('testObject/testKey');
 72 | 
 73 | 
 74 | 
 75 | 
 76 | // Delete the node with key = test
 77 | $firebase->delete('test');
 78 | 
 79 | // Delete the multilevel node and all it's children
 80 | $firebase->delete('testObject/testKey');
 81 | 
 82 | 
 83 | ```
 84 | 
 85 | // 
 86 | 
 87 | ## Others
 88 | 
 89 | This package works perfectly fine for my use case for now. Should you have any other
 90 | use cases that requires me to extend the features, or suggestions how this package
 91 | can be improved, feel free to open issues or email me at luqmanrom@gmail.com
 92 | 
 93 | 
 94 | ## License 
 95 | 
 96 | #### The MIT License (MIT)
 97 | ```
 98 | Copyright (c) 2012-2016 Tamas Kalman
 99 | 
100 | Permission is hereby granted, free of charge, to any person obtaining a copy
101 | of this software and associated documentation files (the "Software"), to deal
102 | in the Software without restriction, including without limitation the rights
103 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
104 | copies of the Software, and to permit persons to whom the Software is
105 | furnished to do so, subject to the following conditions:
106 | 
107 | The above copyright notice and this permission notice shall be included in
108 | all copies or substantial portions of the Software.
109 | 
110 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
111 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
112 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
113 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
114 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
115 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
116 | THE SOFTWARE.
117 | ```	
118 | 
119 | 
120 | 
121 | 


--------------------------------------------------------------------------------