Get best of the week

Recibir mensajes de transmisiones de youtube + autorización de google en PHP

El otro día hubo una tarea de recibir mensajes del flujo de youtube. No encontré artículos sobre este tema, pero solo hay offs. documentación de google Lo descubrí (espero) y estoy listo para compartir mi experiencia con usted.

imagen

Lo primero que encontré fue el método LiveChatMessages: list , parece que todo es simple, pero el parámetro requerido es pasar liveChatId, que puedes obtener haciendo una solicitud a LiveBroadcasts: list , pero para hacer una solicitud allí, debes autorizar al usuario a través de google con acceso a Lectura de cuenta. En los ejemplos, todo se explica detalladamente, pero si está leyendo este artículo, puede que no sea tan claro como nos gustaría.

Iniciar sesión


Consola de Google


Al usar OAuth 2.0 para aplicaciones de servidor web , quiero señalar de inmediato que se requiere autorización de servidor web, porque la clave transmitida durante la autorización a js dura una hora y no se actualizará (sin la participación del usuario). El token de actualización no se transmite. Además, recomiendo usar una de las bibliotecas listas para usar, todo será mucho más fácil con ellas.

Primero, crea una cuenta. Vaya a console.developers.google.com , seleccione los proyectos en la esquina superior izquierda y haga clic en "Crear proyecto".



Ingrese un nombre y guarde. Ahora seleccione su proyecto y haga clic en "Habilitar API y servicios" o vaya a la página de la biblioteca API .
Aquí, en la consulta de búsqueda, busque y habilite la API de datos de YouTube v3.

Luego, en la pestaña "Ventana de solicitud de acceso de OAuth" en el panel izquierdo de la consola ( o aquí ), cree una ventana.
En el primer paso, seleccione "Externo" para el Tipo de usuario.



A continuación, en este formulario debe completar 2 campos: el nombre de la aplicación y "Dominios autorizados", si tiene un dominio, puede dejar el campo vacío si no hay ninguno. Clic en Guardar. El resultado debería ser algo así como



Ahora vaya a la pestaña "Credenciales" (https://console.developers.google.com/apis/credentials)

Aquí encontrará una página de este tipo:



Seleccione el botón "Crear credenciales" -> "Identificador Cliente OAuth »
Seleccione el tipo que desee (para nosotros, la web), ingrese el nombre y "URI de redireccionamiento permitido": esta es la url a la que se enviará el código para autorizar al cliente. Puede escribir aquí una url local en el momento del desarrollo, en mi caso será
http: // localhost: 8080 / oauth2callback.php

Resultado




Después de eso, debería aparecer una ventana con la identificación del cliente y la clave secreta. Mientras esto se cierra de forma segura. Aquí hay una página con las credenciales recién creadas.



Haga clic en el botón Descargar para obtener un identificador:



puede cambiarle el nombre inmediatamente a secret_json.json.

Esto se hace con la configuración de la autorización, ahora vayamos al código.

Php


Cree un proyecto, abra una terminal y ejecute el comando:

php composer.phar require google/apiclient:^2.0

Si no sabe qué es el compositor y cómo instalarlo, familiarícese.
Después de la instalación, cree 2 archivos: index.php y oauth2callback.php. Por
cierto, ya puede iniciar su servidor PHP:

php -S localhost:8080

También mueva el archivo secret_json.json (que descargó anteriormente) a la carpeta del proyecto.

Directamente en Index.php enviará al usuario para su autorización. Contenido del archivo Index.php

<?php
require_once __DIR__ . '/vendor/autoload.php';

$client = new Google_Client();
//     
$client->setAuthConfig('client_secret.json');
//   
$client->setScopes([
    'https://www.googleapis.com/auth/youtube.readonly',
]);
//    refresh_token
$client->setAccessType("offline");

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
    $client->setAccessToken($_SESSION['access_token']);
} else {
    $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php';
    header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
    exit();
}

$refreshToken = $_SESSION['access_token']['refresh_token'];
$accessToken = $_SESSION['access_token']['access_token'];
$tknType = $_SESSION['access_token']['token_type'];
$clientId = $client->getClientId();
$created = $_SESSION['access_token']['created'];
unset($_SESSION['access_token']);
unset($_SESSION['user']);
session_destroy();

$data = json_encode([
  'refreshToken' => $refreshToken,
    'accessToken' => $accessToken,
    'tknType' => $tknType,
    'clientId' => $clientId,
    'created' => $created
]);
echo $data;

De hecho, este código le dará al usuario todos los datos necesarios, puede escribirlos en la base de datos (o bloc de notas).

Archivo oauth2callback.php:

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google_Client();
$client->setAuthConfigFile('client_secret.json');
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
$client->setScopes([
    'https://www.googleapis.com/auth/youtube.readonly',
]);
$client->setApprovalPrompt('force');
$client->setAccessType("offline");

if (!isset($_GET['code'])) {
    $auth_url = $client->createAuthUrl();
    header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
} else {
    $client->authenticate($_GET['code']);
    $_SESSION['access_token'] = $client->getAccessToken();
    $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/';
    header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

Este archivo redirigirá al usuario a la página de autorización de Google y escribirá los datos del token en la sesión. Después, devolverá al usuario a donde index.php continuará trabajando con ellos.
Por supuesto, puede escribir todos los datos directamente en oauth2callback y no redirigir al usuario de nuevo al índice, o puede especificar el siguiente punto en cualquier dirección que sea conveniente para usted. Además, los errores de autorización no se tuvieron en cuenta en este código, tenga esto en cuenta.

Esto se hace con autorización. Ya tienes access_token y refresh_token, obtengamos YouTube.

Youtube


PHP de inmediato


getStreams.php:

<?php
require_once __DIR__ . '/vendor/autoload.php';
//   
require_once __DIR__ . '/refreshToken.php';

$client = new Google_Client();
$client->setAuthConfig('client_secret.json');
$client->setScopes([
    'https://www.googleapis.com/auth/youtube.readonly',
]);
$client->setAccessType("offline");

//  $data      (   )
if (($data['created'] - time()) <= -3600) {
    $data = refreshToken($data['refreshToken'], $db);
}

$client->setAccessToken($data['accessToken']);
$service = new Google_Service_YouTube($client);
//  2          , 
//       .
$queryParams = [
    'broadcastStatus' => 'upcoming',
    'maxResults' => 50
];
$response = $service->liveBroadcasts->listLiveBroadcasts('id,snippet,status', $queryParams);
$items = $response['items'];
$streamsUpcoming = itemsGenerator($items);

$queryParams = [
    'broadcastStatus' => 'active',
    'maxResults' => 50
];
$response = $service->liveBroadcasts->listLiveBroadcasts('id,snippet,status', $queryParams);
$items = $response['items'];
$streamsActive = itemsGenerator($items);
$streams = array_merge($streamsUpcoming, $streamsActive);

//  
echo json_encode($streams);

//     ,   .
function itemsGenerator($items) {
    $streams = [];
    foreach ($items as $item) {
        //       (  )
        if (!isset($item['snippet']['actualEndTime'])) {
            $streams[] = [
                'id' => $item['id'],
                'title' => $item['snippet']['title'],
                'description' => $item['snippet']['description'],
                'image' => $item['snippet']['thumbnails']['medium']['url'],
                'liveChatId' => $item['snippet']['liveChatId'],
                'channelId' => $item['snippet']['channelId']
            ];
        }
    }
    return $streams;
}

¿Recuerdas estas líneas durante la autorización?

$client->setScopes([
    'https://www.googleapis.com/auth/youtube.readonly',
]);

Por lo tanto, son responsables de qué tipo de acceso necesita. Por ejemplo, tal registro solo permite leer información, hay https://www.googleapis.com/auth/youtube.uploadotros.

refreshToken.php:

<?php
require_once __DIR__ . '/vendor/autoload.php';

/**
 * @param string $refreshToken
 * @param $db
 * @return array
 * @throws Google_Exception
 */
function refreshToken($refreshToken, $db)
{
    $client = new Google_Client();
    $client->setAuthConfig('client_secret.json');
    $client->setScopes([
        'https://www.googleapis.com/auth/youtube.readonly',
    ]);
    $client->setAccessType("offline");

    $client->refreshToken($refreshToken);
    $accessToken = $client->getAccessToken();

    $refreshToken = $accessToken['refresh_token'];
    $accessToken = $accessToken['access_token'];
    $clientId = $client->getClientId();
    $data = [
        'refreshToken' => $refreshToken,
        'accessToken' => $accessToken,
        'tknType' => 'Bearer',
        'clientId' => $clientId,
        'created' => time()
    ];

    //      , .

    return $data;
}

El token emitido por Google es válido solo por una hora. Durante el día puede realizar solo 25 solicitudes para actualizar el token, esta función solo actualiza nuestro token y devuelve nuevos valores con los que puede continuar trabajando. GetStreams demuestra su trabajo.

Y finalmente
getStreamMessages.php:

<?php
require_once __DIR__ . '/vendor/autoload.php';
require_once __DIR__ . '/refreshToken.php';

$client = new Google_Client();
$client->setAuthConfig('client_secret.json');
$client->setScopes([
    'https://www.googleapis.com/auth/youtube.readonly',
]);
$client->setAccessType("offline");
// $data -      
if (($data['created'] - time()) <= -3600) {
    $data = refreshToken($data['refreshToken'], $db);
}
$client->setAccessToken($data['accessToken']);

$service = new Google_Service_YouTube($client);

$queryParams = [
    'maxResults' => 2000,
    'profileImageSize' => 120
];

$response = $service->liveChatMessages->listLiveChatMessages($liveChatId, 'id,snippet,authorDetails', $queryParams);

echo json_encode($response);

Aquí no comencé a llevar el formato del mensaje al formato deseado, puede hacerlo usted mismo, la matriz $ response contiene toda la información necesaria y el enlace al artículo está aquí .

Lo que me molesta es que no hay un método para obtener ganchos (si hay uno, deje un enlace, por favor) y tiene que hacer solicitudes constantes.

Además, le recomiendo leer la documentación de liveChatMessages, hay algunas restricciones, como que necesita hacer una solicitud para cada página con un nuevo código que vino en la solicitud anterior.

Proyecto Github con db (todo lo que queda es cargar el archivo client_secret.json)

More articles:


All Articles