Skapa, uppdatera eller ta bort Google Kalender i Java

Google Calendar är en schemaläggningstjänst som låter dig skapa och hålla reda på händelser som möten. Du kan logga händelserna i kalendern och få påminnelser om de kommande. Google låter dig också använda sin kalendertjänst programmatiskt. Således kan du hantera dina händelser med hjälp av Google-kalendrar från dina applikationer. I den här artikeln kommer du att lära dig hur du skapar, uppdaterar och tar bort Google Kalender programmatiskt i Java.

• Java API för att skapa och manipulera Google Kalender
• Skapa en Google-kalender i Java
• Uppdatera en Google Kalender i Java
• Ta bort en Google-kalender i Java

Java API för att skapa och manipulera Google Kalender

För att kunna arbeta med tjänsten Google Kalender kommer vi att använda Aspose.Email for Java. Det är ett kraftfullt API som tillhandahåller en rad funktioner för att behandla e-postmeddelanden, arbeta med e-postklienter och använda Googles samarbetstjänster. Du kan antingen ladda ner API:et eller installera det med hjälp av följande Maven-konfigurationer.

Förvar:

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

Beroende:

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

Skapa en Google-kalender i Java

Innan du börjar måste du skapa ett projekt på Google Developer Console för att din applikation ska kunna kommunicera med Googles tjänster. För att skapa en kan du följa denna guide.

Skapa nu en hjälpklass vid namn GoogleOAuthHelper för att ta hand om autentiseringen av ett Google-konto. Skapa också en klass som heter OAuthUser för att lagra användarinformation. Följande är den fullständiga implementeringen av båda klasserna.

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>
 * Utvecklarkonsol https://console.developers.google.com/projectselector/apis/credentials?pli=1 
 * Dokumentation 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) {
            // ignorera
        }
        return result.toString();
    }
}

När du har gjort ovanstående konfiguration kan du fortsätta att arbeta med tjänsten Google Kalender. Följande är stegen för att skapa och uppdatera en Google Kalender i Java.

• Hämta en instans av klassen GmailClient till ett IGmailClient-objekt med metoden GmailClient.getInstance(String, String).
• Skapa en instans av klassen Calendar och initiera den med namn, beskrivning och andra egenskaper.
• Ring metoden IGmailClient.createCalendar(Calendar) för att skapa Google Kalender.
• Få kalenderns returnerade ID.

Följande kodexempel visar hur du skapar en Google Kalender i Java.

OAuthUser user = new OAuthUser();

// Ställ in clientId, clientSecret och e-post 
user.clientId = "<<clientID>>"; 
user.clientSecret = "<<clientSecret>>"; 
user.email = "<<email>>";

// Du måste hämta AuthorizationCode manuellt med genererad AuthorizationCodeUrl
// Ställ in auktoriseringskod
String authorizationCode = "<<authCode>>";

// Kopiera kodverifierare från föregående steg
// Ställ in codeVerifier
String codeVerifier = "<<codeVerifier>>";

// Få Refresh Token
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;

// Få åtkomsttoken
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);

// Skapa Gmail-klient
try (IGmailClient client = GmailClient.getInstance(accessToken, user.email)) {
    // Infoga, hämta och uppdatera kalender
    Calendar calendar = new Calendar("Summary", "Description", "Location", "America/Los_Angeles");

    // Infoga kalender och hämta samma kalender med id
    String id = client.createCalendar(calendar);
}

Uppdatera en Google Kalender i Java

Följande är stegen för att uppdatera en Google-kalender programmatiskt i Java.

• Hämta en instans av klassen GmailClient till ett IGmailClient-objekt med metoden GmailClient.getInstance(String, String).
• Använd metoden IGmailClient.fetchCalendar(String) för att hämta kalenderinstansen med dess ID.
• Uppdatera egenskaperna för kalendern och anropa metoden IGmailClient.updateCalendar(Calendar) för att uppdatera kalendern.

Följande kodexempel visar hur du uppdaterar en Google-kalender i Java.

// Skapa Gmail-klient
try (IGmailClient client = GmailClient.getInstance(accessToken, email)) {
    // Ange kalender-ID
    String id ="<<calendar ID>>"
      
    // Hämta kalender
    Calendar cal = client.fetchCalendar(id);

    // Ändra information i den hämtade kalendern och uppdatera kalendern
    cal.setDescription("New Description");
    cal.setLocation("New Location");
  
    // Uppdatera kalender
    client.updateCalendar(cal);
}

Ta bort en Google-kalender i Java

Du kan också ta bort en viss kalender med Aspose.Email för Java. Följande är stegen för att utföra denna operation.

• Hämta en instans av klassen GmailClient till ett IGmailClient-objekt med metoden GmailClient.getInstance(String, String).
• Få lista över kalendrar med metoden IGmailClient.listCalendars().
• Gå igenom listan och filtrera den önskade.
• Ta bort kalender med metoden IGmailClient.deleteCalendar(Calendar.getId()).

Följande kodexempel visar hur man tar bort en Google-kalender i Java.

// Skapa Gmail-klient
try (IGmailClient client = GmailClient.getInstance(accessToken, email)) {
    // Öppna och ta bort kalender med sammanfattning från "Kalendersammanfattning"
    String summary = "Calendar summary";

    // Få kalendrar lista
    ExtendedCalendar[] lst = client.listCalendars();

   for (ExtendedCalendar extCal : lst) {
        // Ta bort valda kalendrar
        if (extCal.getSummary().startsWith(summary))
            client.deleteCalendar(extCal.getId());
    }
}

Skaffa en gratis API-licens

Du kan få en gratis temporär licens för att använda Aspose.Email för Java utan utvärderingsbegränsningar.

Slutsats

I den här artikeln har du lärt dig hur du skapar Google Kalender programmatiskt i Java. Dessutom har du sett hur du uppdaterar och tar bort en viss Google-kalender i Java. Dessutom kan du utforska dokumentationen för att läsa mer om Aspose.Email för Java. Du kan också ställa dina frågor via vårt forum.

Se även

• Läs e-postmeddelanden från MS Exchange Server med Java
• Skapa och skicka Outlook-e-postmeddelanden med Java