Crie, atualize ou exclua o Google Agenda em Java

Google Agenda é um serviço de agendamento que permite criar e acompanhar eventos como reuniões. Você pode registrar os eventos no calendário e receber lembretes sobre os próximos. O Google também permite que você use seu serviço de calendário programaticamente. Assim, você pode gerenciar seus eventos usando o Google Calendars a partir de seus aplicativos. Neste artigo, você aprenderá a criar, atualizar e excluir o Google Agenda programaticamente em Java.

• API Java para criar e manipular o Google Agenda
• Criar um Google Agenda em Java
• Atualizar um Google Agenda em Java
• Excluir um Google Agenda em Java

API Java para criar e manipular o Google Agenda

Para trabalhar com o serviço Google Agenda, usaremos Aspose.Email for Java. É uma API poderosa que fornece uma variedade de recursos para processar e-mails, trabalhar com clientes de e-mail e usar os serviços de colaboração do Google. Você pode baixar a API ou instalá-la usando as seguintes configurações do Maven.

Repositório:

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

Dependência:

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

Criar um Google Agenda em Java

Antes de começar, você precisa criar um projeto no Google Developer Console para que seu aplicativo se comunique com os serviços do Google. Para criar um, você pode seguir este guia.

Agora, crie uma classe auxiliar chamada GoogleOAuthHelper para cuidar da autenticação de uma conta do Google. Além disso, crie uma classe chamada OAuthUser para armazenar informações do usuário. A seguir está a implementação completa de ambas as 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 de desenvolvedores https://console.developers.google.com/projectselector/apis/credentials?pli=1 
 * Documentação 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) {
            // ignorar
        }
        return result.toString();
    }
}

Depois de ter feito a configuração acima, você pode continuar a trabalhar com o serviço Google Agenda. A seguir estão as etapas para criar e atualizar um Google Agenda em Java.

• Obtenha uma instância da classe GmailClient em um objeto IGmailClient usando o método GmailClient.getInstance(String, String).
• Crie uma instância da classe Calendar e inicialize-a com nome, descrição e outras propriedades.
• Chame o método IGmailClient.createCalendar(Calendar) para criar o Google Agenda.
• Obtenha o ID retornado do calendário.

O exemplo de código a seguir mostra como criar um Google Agenda em Java.

OAuthUser user = new OAuthUser();

// Definir clientId, clientSecret e email 
user.clientId = "<<clientID>>"; 
user.clientSecret = "<<clientSecret>>"; 
user.email = "<<email>>";

// Você precisa recuperar AuthorizationCode manualmente com AuthorizationCodeUrl gerado
// Definir código de autorização
String authorizationCode = "<<authCode>>";

// Copie o verificador de código da saída da etapa anterior
// Definir codeVerifier
String codeVerifier = "<<codeVerifier>>";

// Obter token de atualização
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;

// Obter token de acesso
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);

// Criar cliente Gmail
try (IGmailClient client = GmailClient.getInstance(accessToken, user.email)) {
    // Inserir, obter e atualizar o calendário
    Calendar calendar = new Calendar("Summary", "Description", "Location", "America/Los_Angeles");

    // Inserir calendário e recuperar o mesmo calendário usando id
    String id = client.createCalendar(calendar);
}

Atualizar um Google Agenda em Java

A seguir estão as etapas para atualizar um Google Agenda programaticamente em Java.

• Obtenha uma instância da classe GmailClient em um objeto IGmailClient usando o método GmailClient.getInstance(String, String).
• Use o método IGmailClient.fetchCalendar(String) para buscar a instância de calendário usando seu ID.
• Atualize as propriedades do calendário e chame o método IGmailClient.updateCalendar(Calendar) para atualizar o calendário.

O exemplo de código a seguir mostra como atualizar um calendário do Google em Java.

// Criar cliente Gmail
try (IGmailClient client = GmailClient.getInstance(accessToken, email)) {
    // Especifique o ID do calendário
    String id ="<<calendar ID>>"
      
    // Buscar calendário
    Calendar cal = client.fetchCalendar(id);

    // Alterar informações no calendário buscado e atualizar o calendário
    cal.setDescription("New Description");
    cal.setLocation("New Location");
  
    // Atualizar calendário
    client.updateCalendar(cal);
}

Excluir um Google Agenda em Java

Você também pode excluir um calendário específico usando Aspose.Email para Java. A seguir estão as etapas para realizar esta operação.

• Obtenha uma instância da classe GmailClient em um objeto IGmailClient usando o método GmailClient.getInstance(String, String).
• Obtenha a lista de calendários usando o método IGmailClient.listCalendars().
• Percorra a lista e filtre o desejado.
• Exclua o calendário usando o método IGmailClient.deleteCalendar(Calendar.getId()).

O exemplo de código a seguir mostra como excluir um Google Agenda em Java.

// Criar cliente Gmail
try (IGmailClient client = GmailClient.getInstance(accessToken, email)) {
    // Acesse e exclua o calendário com resumo a partir de "Resumo do calendário"
    String summary = "Calendar summary";

    // Obter lista de calendários
    ExtendedCalendar[] lst = client.listCalendars();

    for (ExtendedCalendar extCal : lst) {
        // Excluir calendários selecionados
        if (extCal.getSummary().startsWith(summary))
            client.deleteCalendar(extCal.getId());
    }
}

Obtenha uma licença de API gratuita

Você pode obter uma licença temporária gratuita para usar o Aspose.Email for Java sem limitações de avaliação.

Conclusão

Neste artigo, você aprendeu como criar o Google Agenda programaticamente em Java. Além disso, você viu como atualizar e excluir um determinado Google Calendar em Java. Além disso, você pode explorar a documentação para ler mais sobre o Aspose.Email para Java. Além disso, você pode fazer suas perguntas através do nosso fórum.

Veja também

• Leia e-mails do MS Exchange Server usando Java
• Criar e enviar mensagens de email do Outlook usando Java