[Mia] Implementation of Google Calendar API access utilizing Auth Code and Refresh Token (Go and Flutter)

import 'package:clocky_app/api/api_client_provider.dart';
import 'package:clocky_app/api/user_notifier.dart';
import 'package:clocky_app/firebase_options.dart';
import 'package:clocky_app/services/google_calendar_auth_service.dart';
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:google_sign_in/google_sign_in.dart';

class CalendarIntegrationScreen extends ConsumerWidget {
  const CalendarIntegrationScreen({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('カレンダー連携'),
      ),
      body: Center(
        child: ElevatedButton(
          onPressed: () async {
            await _fetchTodayEvents(context, ref);
          },
          child: const Text('Googleカレンダーと連携する'),
        ),
      ),
    );
  }

  Future _fetchTodayEvents(BuildContext context, WidgetRef ref) async {
    try {
      // UserNotifier からユーザー情報を取得
      final user = ref.watch(userProvider);
      if (user == null) {
        throw Exception('ユーザー情報がロードされていません');
      }

      final internalUserId = user.id;
      if (internalUserId == null) {
        throw Exception('内部ユーザーIDが存在しません');
      }
      debugPrint('取得した内部ユーザーID: $internalUserId');

      // Google Sign-Inの初期化
      final GoogleSignIn googleSignIn = GoogleSignIn(
        scopes: [
          'https://www.googleapis.com/auth/calendar.readonly',
          'https://www.googleapis.com/auth/calendar',
        ],
        clientId: DefaultFirebaseOptions.ios.iosClientId,
        serverClientId:
            'XXXXXX.apps.googleusercontent.com', // WebクライアントID
      );

      // Googleサインインを実行
      final account = await googleSignIn.signIn();
      if (account == null) {
        debugPrint('Googleサインインがキャンセルされました');
        return;
      }

      // 認証コードの取得
      final authCode = account.serverAuthCode;
      if (authCode == null) {
        throw Exception('認証コードが取得できませんでした');
      }
      debugPrint('取得した認証コード: $authCode');

      // サーバーに認証コードを送信してリフレッシュトークンを取得・保存
      final googleCalendarService =
          GoogleCalendarService(apiClient: ref.read(apiClientProvider));
      await googleCalendarService.sendAuthCode(
          internalUserId.toString(), authCode);
      debugPrint('リフレッシュトークンの取得に成功しました');
    } catch (e) {
      debugPrint('エラーが発生しました: $e');
    }
  }
}

import 'package:clocky_app/api/api_client.dart';

class GoogleCalendarService {
  final ApiClient apiClient;
  GoogleCalendarService({required this.apiClient});

  // 認可コードをバックエンドに送信
  Future sendAuthCode(String userId, String authCode) async {
    await apiClient.sendAuthCode(userId, authCode);
  }
}

extension GoogleCalendarApi on ApiClient {
  Future sendAuthCode(String userId, String authCode) async {
    final url = Uri.parse('$apiUrl/app/google-calendar/tokens');
    final headers = await apiHeaders();

    final body = {
      'userId': int.parse(userId),
      'authCode': authCode,
    };

    final response = await http.post(
      url,
      headers: headers,
      body: jsonEncode(body),
    );

    if (response.statusCode != 200) {
      throw Exception('Failed to send auth code: ${response.body}');
    }
  }
}

package http

import (
	"context"
	"net/http"
	"time"

	"log/slog"

	"github.com/EarEEG-dev/clocky_be/mia"
	"github.com/EarEEG-dev/clocky_be/mia/google"
	"github.com/labstack/echo/v4"
)


type GoogleCalendarTokenRequest struct {
	UserID   uint64 `json:"userId" validate:"required"`
	AuthCode string `json:"authCode" validate:"required"`
}


type GoogleCalendarTokenService interface {
	SaveToken(ctx context.Context, token mia.GoogleCalendarToken) error
	GetTokenByUserID(ctx context.Context, userID uint64) (mia.GoogleCalendarToken, error)
}


type GoogleCalendarTokenHandler struct {
	TokenValidator *google.GoogleCalendarTokenValidator
	TokenService   GoogleCalendarTokenService
}


func NewGoogleCalendarTokenHandler(
	tokenValidator *google.GoogleCalendarTokenValidator,
	tokenService GoogleCalendarTokenService,
) *GoogleCalendarTokenHandler {
	return &GoogleCalendarTokenHandler{
		TokenValidator: tokenValidator,
		TokenService:   tokenService,
	}
}

// 認証コードをリフレッシュトークンに交換しデータベースに保存
func (h *GoogleCalendarTokenHandler) HandleExchangeAuthCode(c echo.Context) error {
	var req GoogleCalendarTokenRequest
	if err := c.Bind(&req); err != nil {
		slog.Error("Failed to bind request", slog.Any("error", err))
		return c.JSON(http.StatusBadRequest, map[string]string{"error": "Invalid request payload"})
	}

	// リクエスト内容のデバッグログ
	slog.Info("Received request", "userID", req.UserID, "authCode", req.AuthCode)


	// リクエストのバリデーション
	if req.UserID == 0 || req.AuthCode == "" {
		return c.JSON(http.StatusBadRequest, map[string]string{"error": "userId and authCode are required"})
	}

	ctx := context.Background()

	// AuthCodeを使用してアクセストークンとリフレッシュトークンを取得
	token, err := h.TokenValidator.ExchangeAuthCode(ctx, req.AuthCode)
	if err != nil {
		slog.Error("Failed to exchange auth code", slog.Any("error", err))
		return c.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to exchange auth code"})
	}

	// トークン内容のデバッグログ
	slog.Info("Token exchanged successfully", "accessToken", token.AccessToken, "refreshToken", token.RefreshToken, "expiry", token.Expiry)


	// トークンデータを構築
	googleToken := mia.GoogleCalendarToken{
		UserID:       req.UserID,
		RefreshToken: token.RefreshToken,
		CreatedAt:    time.Now(),
		UpdatedAt:    time.Now(),
	}

	// トークンをデータベースに保存
	if err := h.TokenService.SaveToken(ctx, googleToken); err != nil {
		slog.Error("Failed to save Google Calendar token", slog.Any("error", err))
		return c.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to save token"})
	}

	return c.JSON(http.StatusOK, map[string]string{"message": "Token saved successfully"})
}

package google

import (
	"context"
	"errors"
	"fmt"
	"os"

	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"google.golang.org/api/calendar/v3"
	"google.golang.org/api/option"
)

// GoogleCalendarTokenValidator は Google Calendar API のトークン操作を行う構造体
type GoogleCalendarTokenValidator struct {
	Service     *calendar.Service
	PackageName string
	Config      *oauth2.Config
}

// NewGoogleCalendarTokenValidator は Google Calendar API 用の Token Validator を初期化する
func NewGoogleCalendarTokenValidator() (*GoogleCalendarTokenValidator, error) {
	// 環境変数からOAuth 2.0クライアント情報を取得
	clientID := os.Getenv("GOOGLE_CLIENT_ID")
	clientSecret := os.Getenv("GOOGLE_CLIENT_SECRET")
	redirectURI := os.Getenv("GOOGLE_REDIRECT_URI")

	// 必須情報が不足している場合はエラー
	if clientID == "" || clientSecret == "" || redirectURI == "" {
		return nil, errors.New("missing required environment variables: GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, GOOGLE_REDIRECT_URI")
	}

	// OAuth2 Config の初期化
	config := &oauth2.Config{
		ClientID:     clientID,
		ClientSecret: clientSecret,
		RedirectURL:  redirectURI,
		Scopes:       []string{calendar.CalendarScope},
		Endpoint:     google.Endpoint,
	}

	// Google Calendar Service の初期化
	ctx := context.Background()
	service, err := calendar.NewService(ctx, option.WithHTTPClient(config.Client(ctx, nil)))
	if err != nil {
		return nil, fmt.Errorf("failed to initialize Google Calendar service: %w", err)
	}

	// Validator の初期化
	return &GoogleCalendarTokenValidator{
		Service: service,
		Config:  config,
	}, nil
}

// ExchangeAuthCode は認証コードをアクセストークンおよびリフレッシュトークンに交換します
func (v *GoogleCalendarTokenValidator) ExchangeAuthCode(ctx context.Context, authCode string) (*oauth2.Token, error) {
	if v.Config == nil {
		return nil, errors.New("OAuth2 config is not initialized")
	}

	// 認証コードをアクセストークンに交換
	token, err := v.Config.Exchange(ctx, authCode)
	if err != nil {
		return nil, fmt.Errorf("failed to exchange auth code: %w", err)
	}

	return token, nil
}

{
  "web": {
    "client_id": "YOUR_WEB_CLIENT_ID.apps.googleusercontent.com",
    "project_id": "your-project-id",
    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
    "token_uri": "https://oauth2.googleapis.com/token",
    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
    "client_secret": "YOUR_CLIENT_SECRET",
    "redirect_uris": ["https://your-app-url/callback"]
  }
}

{
  "access_token": "ya29.a0AfH6SMC...",
  "expires_in": 3599,
  "refresh_token": "1//0g5fDh...",
  "scope": "https://www.googleapis.com/auth/calendar",
  "token_type": "Bearer"
}