Créer, mettre à jour ou supprimer Google Calendar en Java

Google Calendar est un service de planification qui vous permet de créer et de suivre des événements tels que des réunions. Vous pouvez enregistrer les événements sur le calendrier et recevoir des rappels sur les événements à venir. Google vous permet également d’utiliser son service de calendrier par programmation. Ainsi, vous pouvez gérer vos événements à l’aide de Google Calendars depuis vos applications. Dans cet article, vous apprendrez à créer, mettre à jour et supprimer Google Agenda par programmation en Java.

• API Java pour créer et manipuler Google Calendar
• Créer un agenda Google en Java
• Mettre à jour un agenda Google en Java
• Supprimer un agenda Google en Java

API Java pour créer et manipuler Google Calendar

Afin de travailler avec le service Google Calendar, nous utiliserons Aspose.Email for Java. Il s’agit d’une API puissante qui fournit une gamme de fonctionnalités pour le traitement des e-mails, l’utilisation de clients de messagerie et l’utilisation des services de collaboration de Google. Vous pouvez soit télécharger l’API ou l’installer à l’aide des configurations Maven suivantes.

Repository:

<repository>
    <id>AsposeJavaAPI</id>
    <name>Aspose Java API</name>
    <url>http://repository.aspose.com/repo/</url>
</repository>

Dependency:

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-email</artifactId>
    <version>22.3</version>
    <classifier>jdk16</classifier>
</dependency>

Créer un agenda Google en Java

Avant de commencer, vous devez créer un projet sur la Google Developer Console pour que votre application puisse communiquer avec les services de Google. Pour en créer un, vous pouvez suivre ce guide.

Maintenant, créez une classe d’assistance nommée GoogleOAuthHelper pour prendre en charge l’authentification d’un compte Google. Créez également une classe nommée OAuthUser pour stocker les informations utilisateur. Ce qui suit est l’implémentation complète des deux classes.

public class OAuthUser {
        String email;
        String clientId;
        String clientSecret;
        String refreshToken;
    }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import javax.xml.bind.DatatypeConverter;

/**
 * <p>
 * Console développeurs https://console.developers.google.com/projectselector/apis/credentials?pli=1 
 * Documentation https://developers.google.com/identity/protocols/OAuth2InstalledApp
 * </p>
 */
class GoogleOAuthHelper {
    public static final String AUTHORIZATION_URL = "https://accounts.google.com/o/oauth2/v2/auth";
    public static final String TOKEN_REQUEST_URL = "https://oauth2.googleapis.com/token";
    public static final String REDIRECT_URI = "urn:ietf:wg:oauth:2.0:oob";
    public static final String REDIRECT_TYPE = "code";
    public static final String SCOPE = "https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcalendar" // Calendar
            + "+https%3A%2F%2Fwww.google.com%2Fm8%2Ffeeds%2F" // Contacts
            + "+https%3A%2F%2Fmail.google.com%2F"; // IMAP & SMTP

    static String createCodeChalange() {
        String verifierStr = UUID.randomUUID().toString() + "-" + UUID.randomUUID().toString();
        System.out.println("Code Verifier: " + verifierStr);

        MessageDigest digest;
        try {
            digest = MessageDigest.getInstance("SHA-256");
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalAccessError(e.getMessage());
        }
        byte[] hash = digest.digest(verifierStr.getBytes(StandardCharsets.UTF_8));
        String base64Hash = DatatypeConverter.printBase64Binary(hash);

        base64Hash = base64Hash.split("=")[0];
        base64Hash = base64Hash.replace('+', '-').replace('/', '_');
        return base64Hash;
    }

    static String getAuthorizationCodeUrl(OAuthUser acc) {
        return getAuthorizationCodeUrl(acc, SCOPE, REDIRECT_URI, REDIRECT_TYPE);
    }

    static String getAuthorizationCodeUrl(OAuthUser acc, String scope, String redirectUri, String responseType) {
        System.out.println("---------------------------------------------------------");
        System.out.println("------------- OAuth 2.0 AuthorizationCodeUrl -------------");
        System.out.println("---------------------------------------------------------");
        System.out.println("Login: " + acc.email);
        String codeChallenge = createCodeChalange();

        String state = urlEncode(UUID.randomUUID().toString());
        String approveUrl = AUTHORIZATION_URL + "?client_id=" + acc.clientId + "&redirect_uri=" + redirectUri + "&response_type=" + responseType + "&scope=" + scope
                + "&code_challenge=" + codeChallenge + "&code_challenge_method=S256&state=" + state;

        System.out.println("Approve Url: " + approveUrl);
        return approveUrl;
    }

    static String urlEncode(String value) {
        try {
            return URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
        } catch (UnsupportedEncodingException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String urlDecode(String value) {
        try {
            return URLDecoder.decode(value, StandardCharsets.UTF_8.toString());
        } catch (UnsupportedEncodingException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String getAccessTokenByAuthCode(String authorizationCode, String codeVerifier, OAuthUser user) {
        String encodedParameters = "client_id=" + urlEncode(user.clientId) + "&client_secret=" + urlEncode(user.clientSecret) + "&code=" + urlEncode(authorizationCode)
                + "&code_verifier=" + codeVerifier + "&redirect_uri=" + urlEncode(REDIRECT_URI) + "&grant_type=authorization_code";
        System.out.println("---------------------------------------------------------");
        System.out.println("------------- OAuth 2.0 AccessTokenByAuthCode -------------");
        System.out.println("---------------------------------------------------------");
        System.out.println("Authorization code: " + authorizationCode);

        String result = "";
        Map<String, String> token = geToken(encodedParameters);
        for (String key : token.keySet()) {
            System.out.println(key + ": " + token.get(key));
            if (key.equals("refresh_token")) {
                result = token.get(key);
            }
        }

        System.out.println("---------------------------------------------------------");

        return result;
    }

    static String getAccessTokenByRefreshToken(OAuthUser user) {
        String encodedParameters = "client_id=" + urlEncode(user.clientId) + "&client_secret=" + urlEncode(user.clientSecret) + "&refresh_token=" + urlEncode(user.refreshToken)
                + "&grant_type=refresh_token";
        System.out.println("---------------------------------------------------------");
        System.out.println("----------- OAuth 2.0 AccessTokenByRefreshToken -----------");
        System.out.println("---------------------------------------------------------");
        System.out.println("Login: " + user.email);

        String result = "";
        Map<String, String> token = geToken(encodedParameters);
        for (String key : token.keySet()) {
            System.out.println(key + ": " + token.get(key));
            if (key.equals("access_token")) {
                result = token.get(key);
            }
        }

        System.out.println("---------------------------------------------------------");

        return result;
    }

    static Map<String, String> geToken(String encodedParameters) {
        try {
            HttpURLConnection connection = (HttpURLConnection) new URL(TOKEN_REQUEST_URL).openConnection();
            connection.setRequestMethod("POST");

            byte[] requestData = encodedParameters.getBytes(StandardCharsets.UTF_8);

            connection.setUseCaches(false);
            connection.setDoInput(true);
            connection.setDoOutput(true);
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            connection.setRequestProperty("Content-Length", "" + requestData.length);

            final OutputStream st = connection.getOutputStream();
            try {
                st.write(requestData, 0, requestData.length);
            } finally {
                st.flush();
                st.close();
            }

            connection.connect();

            if (connection.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) {
                throw new IllegalAccessError("Operation failed: " + connection.getResponseCode() + "/" + connection.getResponseMessage() + "\r\nDetails:\r\n{2}"
                        + readInputStream(connection.getErrorStream()));
            }

            String responseText = readInputStream(connection.getInputStream());

            Map<String, String> result = new HashMap<String, String>();
            System.out.println(responseText);
            String[] strs = responseText.replace("{", "").replace("}", "").replace("\"", "").replace("\r", "").replace("\n", "").split(",");
            for (String sPair : strs) {
                String[] pair = sPair.split(":");
                String name = pair[0].trim().toLowerCase();
                String value = urlDecode(pair[1].trim());
                result.put(name, value);
            }

            return result;
        } catch (IOException e) {
            throw new IllegalAccessError(e.getMessage());
        }
    }

    static String readInputStream(InputStream is) {
        if (is == null)
            return "";

        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder result = new StringBuilder();
        String line;
        try {
            while ((line = reader.readLine()) != null) {
                result.append(line);
            }
        } catch (IOException e) {
            // ignorer
        }
        return result.toString();
    }
}

Une fois que vous avez effectué la configuration ci-dessus, vous pouvez continuer à travailler avec le service Google Calendar. Voici les étapes pour créer et mettre à jour un agenda Google en Java.

• Obtenez une instance de la classe GmailClient dans un objet IGmailClient à l’aide de la méthode GmailClient.getInstance(String, String).
• Créez une instance de la classe Calendar et initialisez-la avec le nom, la description et d’autres propriétés.
• Appelez la méthode IGmailClient.createCalendar(Calendar) pour créer le calendrier Google.
• Obtenez l’ID renvoyé du calendrier.

L’exemple de code suivant montre comment créer un agenda Google en Java.

OAuthUser user = new OAuthUser();

// Définissez clientId, clientSecret et email 
user.clientId = "<<clientID>>"; 
user.clientSecret = "<<clientSecret>>"; 
user.email = "<<email>>";

// Vous devez récupérer AuthorizationCode manuellement avec AuthorizationCodeUrl généré
// Définir le code d'autorisation
String authorizationCode = "<<authCode>>";

// Copier le vérificateur de code à partir de la sortie de l'étape précédente
// Définir le codeVérificateur
String codeVerifier = "<<codeVerifier>>";

// Obtenir un jeton d'actualisation
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;

// Obtenir un jeton d'accès
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);

// Créer un client Gmail
try (IGmailClient client = GmailClient.getInstance(accessToken, user.email)) {
    // Insérer, obtenir et mettre à jour le calendrier
    Calendar calendar = new Calendar("Summary", "Description", "Location", "America/Los_Angeles");

    // Insérer un calendrier et récupérer le même calendrier en utilisant l'identifiant
    String id = client.createCalendar(calendar);
}

Mettre à jour un agenda Google en Java

Voici les étapes pour mettre à jour un agenda Google par programmation en Java.

• Obtenez une instance de la classe GmailClient dans un objet IGmailClient à l’aide de la méthode GmailClient.getInstance(String, String).
• Utilisez la méthode IGmailClient.fetchCalendar(String) pour récupérer l’instance de calendrier à l’aide de son ID.
• Mettez à jour les propriétés du calendrier et appelez la méthode IGmailClient.updateCalendar(Calendar) pour mettre à jour le calendrier.

L’exemple de code suivant montre comment mettre à jour un agenda Google en Java.

// Créer un client Gmail
try (IGmailClient client = GmailClient.getInstance(accessToken, email)) {
    // Spécifiez l'ID du calendrier
    String id ="<<calendar ID>>"
      
    // Récupérer le calendrier
    Calendar cal = client.fetchCalendar(id);

    // Modifier les informations dans le calendrier récupéré et mettre à jour le calendrier
    cal.setDescription("New Description");
    cal.setLocation("New Location");
  
    // Mettre à jour le calendrier
    client.updateCalendar(cal);
}

Supprimer un agenda Google en Java

Vous pouvez également supprimer un calendrier particulier en utilisant Aspose.Email for Java. Voici les étapes pour effectuer cette opération.

• Obtenez une instance de la classe GmailClient dans un objet IGmailClient à l’aide de la méthode GmailClient.getInstance(String, String).
• Obtenez la liste des calendriers à l’aide de la méthode IGmailClient.listCalendars().
• Parcourez la liste et filtrez celle que vous souhaitez.
• Supprimez le calendrier à l’aide de la méthode IGmailClient.deleteCalendar(Calendar.getId()).

L’exemple de code suivant montre comment supprimer un agenda Google en Java.

// Créer un client Gmail
try (IGmailClient client = GmailClient.getInstance(accessToken, email)) {
    // Accéder et supprimer le calendrier avec un résumé à partir de "Résumé du calendrier"
    String summary = "Calendar summary";

    // Obtenir la liste des calendriers
    ExtendedCalendar[] lst = client.listCalendars();

    for (ExtendedCalendar extCal : lst) {
        // Supprimer les calendriers sélectionnés
        if (extCal.getSummary().startsWith(summary))
            client.deleteCalendar(extCal.getId());
    }
}

Obtenez une licence API gratuite

Vous pouvez obtenir une licence temporaire gratuite pour utiliser Aspose.Email for Java sans limitation d’évaluation.

Conclusion

Dans cet article, vous avez appris à créer Google Agenda par programmation en Java. De plus, vous avez vu comment mettre à jour et supprimer un calendrier Google particulier en Java. En outre, vous pouvez explorer la documentation pour en savoir plus sur Aspose.Email for Java. Vous pouvez également poser vos questions via notre forum.

Voir également

• Lire les e-mails de MS Exchange Server à l’aide de Java
• Créer et envoyer des messages électroniques Outlook à l’aide de Java