Cómo integrar Google Calendar con Laravel paso a paso

Cómo integrar Google Calendar en tu app Laravel

Integrar Google Calendar en tu aplicación Laravel te cambia el juego, sobre todo si necesitás manejar eventos, agendar turnos o seguir vencimientos. En esta guía te llevo por todo el proceso, desde configurar la API de Google hasta sincronizar eventos en tu app Laravel.

Requisitos previos

Antes de meternos en el código, asegurate de tener esto:

• Una aplicación Laravel (yo uso Laravel 8, pero esto anda igual en versiones más nuevas).
• Una cuenta de Google con acceso a Google Calendar.
• Conocimiento básico de rutas, controladores y vistas de Laravel. (Si te falta eso, pronto sale un tutorial.)

Paso 1: crear las credenciales de la API de Google

Lo primero es crear las credenciales para la API de Google Calendar.

• Entrá a la Google Cloud Console: andá a la Google Cloud Console.
• Creá un proyecto nuevo: si todavía no tenés uno, crealo. Ponele un nombre que se entienda, como "Laravel Google Calendar Integration".
• Habilitá la Google Calendar API: en la API Library, buscá "Google Calendar API" y habilitala para tu proyecto.
• Creá credenciales OAuth 2.0: andá a la sección "Credentials". Hacé clic en "Create Credentials" y elegí "OAuth 2.0 Client IDs". Configurá la consent screen y cargá los datos de tu aplicación. Después generá el client ID y el client secret, que los vas a necesitar más adelante.
• Configurá la redirect URI: agregá una redirect URI para tu aplicación, que se usa para manejar el callback de OAuth. Tiene que verse más o menos así: http://yourapp.com/oauth2callback.

Paso 2: instalar la Google Client Library

Ya con las credenciales, vamos a instalar la Google Client Library en la app Laravel. Esta librería simplifica bastante el trabajo contra las APIs de Google.

composer require google/apiclient:^2.0

Paso 3: configurar las variables de entorno

Ahora sumá las credenciales de la API de Google a tu archivo .env. Así los datos sensibles quedan afuera del repo y podés cambiar la configuración entre entornos sin tocar código.

GOOGLE_CLIENT_ID=your-client-id 
GOOGLE_CLIENT_SECRET=your-client-secret 
GOOGLE_REDIRECT_URI=http://yourapp.com/oauth2callback

Acordate de reemplazar los placeholders por tu client ID, tu client secret y tu redirect URI reales.

Paso 4: crear el service de Google Calendar

Para mantener el código ordenado, vamos a crear una clase de service que concentre todas las interacciones con la API de Google Calendar.

Creá la clase de service: en el directorio app/Services, creá una clase nueva llamada GoogleCalendarService.php.

<?php 

namespace App\Services; 
use Google\Client; 
use Google\Service\Calendar; 

class GoogleCalendarService {    
	protected $client;    
	protected $calendarService;    
	
	public function __construct() {        
		$this->client = new Client();        
		$this->client->setClientId(config('services.google.client_id'));        
		$this->client->setClientSecret(config('services.google.client_secret'));        
		$this->client->setRedirectUri(config('services.google.redirect'));        
		$this->client->addScope(Calendar::CALENDAR);        
		$this->calendarService = new Calendar($this->client);    
	}    
	
	public function authenticate($code) {        
		$this->client->authenticate($code);        
		session(['google_access_token' => $this->client->getAccessToken()]);    
	}    
	
	public function getClient()  {        
		if (session('google_access_token')) {            
			$this->client->setAccessToken(session('google_access_token'));        
		}        
		
		return $this->client;    
	}    
	
	public function listEvents($calendarId = 'primary')  {       
		$this->getClient();        
		$events = $this->calendarService->events->listEvents($calendarId);        
		return $events->getItems();    
	}    
	
	public function createEvent($eventData, $calendarId = 'primary')  {        
		$this->getClient();        
		$event = new \Google\Service\Calendar\Event($eventData);        
		$event = $this->calendarService->events->insert($calendarId, $event);
		
		// You can also insert the event in DB to retrieve it from there later        
		return $event;    
	} 
}

Esta clase maneja la autenticación, el listado de eventos y la creación de eventos en Google Calendar.

Paso 5: armar el flujo de OAuth

Para que los usuarios se autentiquen con su cuenta de Google, vamos a armar las rutas y los controladores del flujo de OAuth.

Rutas: agregá estas rutas en tu archivo web.php:

use App\Http\Controllers\GoogleCalendarController; 

Route::get('auth/google', [GoogleCalendarController::class, 'redirectToGoogle']); 
Route::get('auth/google/callback', [GoogleCalendarController::class, 'handleGoogleCallback']);

Controlador: creá un GoogleCalendarController.php en el directorio app/Http/Controllers.

<?php 

namespace App\Http\Controllers; 

use App\Services\GoogleCalendarService; 
use Illuminate\Http\Request; 

class GoogleCalendarController extends Controller {    
	protected $googleService;    
	public function __construct(GoogleCalendarService $googleService)  {        
		$this->googleService = $googleService;    
	}    
	
	public function redirectToGoogle()  {        
		return redirect()->away($this->googleService->getClient()->createAuthUrl());    
	}    
	
	public function handleGoogleCallback(Request $request)  {        
		$this->googleService->authenticate($request->get('code'));        
		return redirect('/')->with('success', 'Google Calendar connected!');    
	} 
}

Este controlador se encarga de redirigir a los usuarios a la consent screen de OAuth de Google y de procesar el callback.

Paso 6: mostrar y manejar los eventos del calendario

Con la autenticación lista, ya podemos interactuar con Google Calendar. Vamos a mostrar una lista de eventos en una vista simple.

Sumá un método al controlador: actualizá GoogleCalendarController.php con un método para mostrar los eventos.

public function showEvents() {    
	$events = $this->googleService->listEvents();    
	return view('events.index', compact('events')); 
}

Creá la vista: en el directorio resources/views/events/, creá un archivo index.blade.php.

@extends('layouts.app') 
@section('content')    
	<h1>Google Calendar Events</h1>    
	
	@if(count($events) > 0)        
		<ul>
			@foreach($events as $event)
				<li>{{ $event->getSummary() }} ({{ $event->getStart()->getDateTime() }})</li>
			@endforeach
		</ul>
	@else
		<p>No events found.</p>
	@endif 
@endsection

Esta vista recorre los eventos que trae Google Calendar y los muestra.

Paso 7: crear un evento nuevo en Google Calendar

Para crear un evento nuevo necesitamos un formulario donde los usuarios carguen los datos.

Creá el formulario: agregá un formulario a la vista index.blade.php para crear eventos.

<form action="{{ route('events.store') }}" method="POST">    
	@csrf    
	<input type="text" name="summary" placeholder="Event Title">    
	<input type="datetime-local" name="start">    
	<input type="datetime-local" name="end">    
	<button type="submit">Add Event</button> 
</form>

Guardá el evento: sumá un método en GoogleCalendarController.php para manejar el envío del formulario.

public function storeEvent(Request $request) {    
	$eventData = [        
		'summary' => $request->summary,        
		'start' => ['dateTime' => $request->start],        
		'end' => ['dateTime' => $request->end],    
	];    
	
	$event = $this->googleService->createEvent($eventData);    
	return redirect()->back()->with('success', 'Event created: ' . $event->getSummary()); }

Agregá la ruta: por último, sumá una ruta para manejar la creación del evento.

Route::post('events', [GoogleCalendarController::class, 'storeEvent'])->name('events.store');

Conclusión

Hay paquetes de terceros que ya traen parte de esta funcionalidad, pero hacerlo a mano sirve para aprender, o si querés control total del codebase de tu plataforma. Y a su vez quedás vos a cargo de mantener el código. Eso es bueno: si vas por un paquete de terceros, ese paquete puede quedar desactualizado durante años.

También conviene estirar el concepto y armar algo de automatización. Por ejemplo, un cron job que traiga los eventos cada X minutos, los guarde en la DB y después los muestre en un calendario. Así te ahorrás llamadas a la API, mejorás el rendimiento y empezás a combinar piezas de lo que podría ser un SaaS.

Como ves, integrar Google Calendar es relativamente fácil, sobre todo en la fase de desarrollo. Tené en cuenta que cuando pases a producción, Google tiene que revisar tu aplicación, y para eso hay que presentar documentación (política de privacidad, EULA, términos de uso, etc.)

¿Te sirvió el post? ¡Compartilo!

-Gonza