「UserManagerというのかい？贅沢な名だね」Flutter/Dartで絶対に迷わないクラス命名パターン12選【実装例つき】

// --- 抽象インターフェースの定義例 ---
abstract class ApiClient {
  Future<Map<String, dynamic>> get(String path, {Map<String, dynamic>? queryParameters});
  Future<Map<String, dynamic>> post(String path, Map<String, dynamic> data);
  Future<Map<String, dynamic>> put(String path, Map<String, dynamic> data);
  Future<void> delete(String path);
}

// --- 実装クラスの定義例 ---
import 'package:dio/dio.dart'; // HTTP通信ライブラリのDioを使用

// 抽象インターフェースの具体的なHTTP実装
class HttpApiClient implements ApiClient {
  final Dio _dio;

  HttpApiClient(this._dio);

  @override
  Future<Map<String, dynamic>> get(String path, {Map<String, dynamic>? queryParameters}) async {
    try {
      final response = await _dio.get(path, queryParameters: queryParameters);
      if (response.statusCode! >= 200 && response.statusCode! < 300) {
        return response.data as Map<String, dynamic>;
      } else {
        // HTTPステータスコードに基づくエラーハンドリング
        throw ApiException('Failed to load data: Status Code ${response.statusCode}');
      }
    } on DioException catch (e) {
      // Dio固有のネットワークエラーやサーバー応答エラーを捕捉し、アプリケーションの例外として返す
      throw ApiException('Network or API error: ${e.message}');
    } catch (e) {
      // その他の予期せぬエラーを捕捉
      throw ApiException('An unexpected error occurred: $e');
    }
  }

  @override
  Future<Map<String, dynamic>> post(String path, Map<String, dynamic> data) async { ... }

  @override
  Future<Map<String, dynamic>> put(String path, Map<String, dynamic> data) async { ... }

  @override
  Future<void> delete(String path) async { ... }
}

// --- カスタム例外クラスの定義例 ---
class ApiException implements Exception {
  final String message;
  ApiException(this.message);

  @override
  String toString() => 'ApiException: $message';
}

Copy

import 'dart:async';
import 'dart:typed_data';

// --- データモデル (Driverがアプリケーションに提供するNFC関連情報) ---
class NdefRecord {
  final Uint8List payload;
  final String? typeNameFormat; // NDEF Type Name Format
  NdefRecord({required this.payload, this.typeNameFormat});

  String get decodedPayloadAsString { // 簡易デコード
    try { return String.fromCharCodes(payload); } catch (_) { return "[Payload Decode Error]"; }
  }
  @override String toString() => 'NdefRecord(tnf: $typeNameFormat, payload: "$decodedPayloadAsString")';
}

class NdefMessage {
  final List<NdefRecord> records;
  NdefMessage({required this.records});
  @override String toString() => 'NdefMessage(records: $records)';
}

class NfcTagInfo {
  final String id; // タグID
  final List<String> techList; // サポート技術
  final dynamic _internalTagRepresentation; // Driver内部で使用するプラグイン固有タグ表現

  NfcTagInfo(this.id, this.techList, this._internalTagRepresentation);
  @override String toString() => 'NfcTagInfo(id: $id, techList: $techList)';
}

class NfcTagPollingEvent {
  final NfcTagInfo? tag;
  final String? errorMessage;
  NfcTagPollingEvent({this.tag, this.errorMessage});
  bool get hasError => errorMessage != null;
  @override String toString() => hasError ? 'NfcTagPollingEvent(error: "$errorMessage")' : 'NfcTagPollingEvent(tag: $tag)';
}

// --- 低レベルなNFC操作APIの例 ---
class _UnderlyingNfcPluginAPI {
  static final _UnderlyingNfcPluginAPI _instance = _UnderlyingNfcPluginAPI._();
  factory _UnderlyingNfcPluginAPI() => _instance;
  _UnderlyingNfcPluginAPI._();

  Future<bool> checkAvailability() async => true; // 常に利用可能とする

  void startTagDiscovery({ // コールバックで結果を返す非同期操作
    required Function(dynamic rawTag) onTagDiscovered,
    required Function(String error) onError,
  }) { ... }

  Future<void> stopTagDiscovery() async { ... }

  Future<Uint8List?> readNdef(dynamic rawTag) async { ... }

  Future<bool> writeNdef(dynamic rawTag, Uint8List ndefMessage) async { ... }
}

// --- NFCデバイスドライバー インターフェース定義 ---
abstract class NfcDeviceDriver {
  Future<bool> isAvailable();
  Stream<NfcTagPollingEvent> startPolling({
    Duration timeout = const Duration(seconds: 10),
    String alertMessage = 'NFCタグを近づけてください',
  });
  Future<void> stopPolling();
  Future<NdefMessage?> readNdefMessage(NfcTagInfo tag);
  Future<void> writeNdefMessage(NfcTagInfo tag, NdefMessage message);
}

// --- NFCデバイスドライバーの実装例 ---
class NfcDriverImpl implements NfcDeviceDriver {
  final _UnderlyingNfcPluginAPI _pluginAPI;

  NfcDriverImpl() : _pluginAPI = _UnderlyingNfcPluginAPI();

  @override
  Future<bool> isAvailable() {
    return _pluginAPI.checkAvailability();
  }

  @override
  Stream<NfcTagPollingEvent> startPolling({
    Duration timeout = const Duration(seconds: 10),
    String alertMessage = 'NFCタグを近づけてください',
  }) {
    final controller = StreamController<NfcTagPollingEvent>();

    _pluginAPI.startTagDiscovery(
      onTagDiscovered: (dynamic rawTag) {
        // 低レベルAPIのデータ構造からDriver定義のNfcTagInfoへ変換
        final tagInfo = _convertToNfcTagInfo(rawTag);
        if (!controller.isClosed) {
          controller.add(NfcTagPollingEvent(tag: tagInfo));
          if (!controller.isClosed) controller.close();
          _pluginAPI.stopTagDiscovery();
        }
      },
      onError: (String error) {
        if (!controller.isClosed) {
          controller.add(NfcTagPollingEvent(errorMessage: error));
          if (!controller.isClosed) controller.close();
        }
      },
    );

    // Driver側でポーリング全体のタイムアウトを設定
    return controller.stream.timeout(timeout, onTimeout: (sink) {
        if (!controller.isClosed) { // controllerの状態を確認
        sink.add(NfcTagPollingEvent(errorMessage: 'Polling timed out by Driver.'));
        sink.close();
        _pluginAPI.stopTagDiscovery(); // タイムアウト時も低レベルAPIのポーリングを停止
      }
    });
  }

  @override
  Future<void> stopPolling() {
    return _pluginAPI.stopTagDiscovery();
  }

  @override
  Future<NdefMessage?> readNdefMessage(NfcTagInfo tag) async {
    final rawNdefData = await _pluginAPI.readNdef(tag._internalTagRepresentation);
    if (rawNdefData == null) return null;
    // 低レベルAPIのデータからDriver定義のNdefMessageへ変換
    return _convertToNdefMessage(rawNdefData);
  }

  @override
  Future<void> writeNdefMessage(NfcTagInfo tag, NdefMessage message) async {
    final rawNdefPayload = _convertFromNdefMessage(message); // Driverの型から低レベルAPIの型へ
    final success = await _pluginAPI.writeNdef(tag._internalTagRepresentation, rawNdefPayload);
    if (!success) {
      throw Exception('Failed to write NDEF message to tag ${tag.id}');
    }
  }

  // --- 型変換ヘルパー (Driverの重要な責務) ---
  NfcTagInfo _convertToNfcTagInfo(dynamic rawTagData) {
    // rawTagData (Map<String, dynamic>を想定) から必要な情報を抽出
    final id = rawTagData['id']?.toString() ?? 'unknown_id';
    final tech = (rawTagData['tech'] as List?)?.map((t) => t.toString()).toList() ?? [];
    return NfcTagInfo(id, tech, rawTagData); // プラグイン固有表現も保持
  }

  NdefMessage _convertToNdefMessage(Uint8List rawNdefData) {
    // rawNdefDataをパースしてNdefRecordのリストを作成する
    return NdefMessage(records: [NdefRecord(payload: rawNdefData, typeNameFormat: 'U')]);
  }

  Uint8List _convertFromNdefMessage(NdefMessage message) {
    // NdefMessageを低レベルAPIが期待するUint8Listにシリアライズする
    if (message.records.isNotEmpty) return message.records.first.payload;
    return Uint8List(0);
  }
}

Copy

// --- 依存コンポーネント定義例 ---
abstract class ApiClient {
  Future<Map<String, dynamic>> get(String path, {Map<String, String>? headers});
  Future<Map<String, dynamic>> post(String path, Map<String, dynamic> data, {Map<String, String>? headers});
}

// --- PaymentGateway（支払いゲートウェイ） ---
// 支払い処理に関するステータス
enum PaymentStatus { pending, success, failed, unknown }

// 支払いゲートウェイのインターフェース
abstract class PaymentGateway {
  Future<bool> processPayment(String userId, double amount, String currency);
  Future<PaymentStatus> getPaymentStatus(String transactionId);
}

// Stripe決済サービスを利用するGatewayの実装例
class StripePaymentGateway implements PaymentGateway {
  final ApiClient _apiClient; // HTTP通信を行うApiClient
  final String _stripeApiKey;

  StripePaymentGateway(this._apiClient, this._stripeApiKey);

  @override
  Future<bool> processPayment(String userId, double amount, String currency) async {
    print('StripePaymentGateway: Processing payment for user $userId, amount $amount $currency');
    try {
      // Stripe APIへのリクエストをApiClient経由で送信
      final response = await _apiClient.post(
        'https://api.stripe.com/v1/charges',
        {
          'amount': (amount * 100).toInt(),
          'currency': currency,
          'customer': userId,
          'description': 'Application Payment via Gateway',
        },
        headers: {'Authorization': 'Bearer $_stripeApiKey'},
      );
      // レスポンスを解析して成功/失敗を判断
      return response['status'] == 'succeeded';
    } catch (e) {
      print('StripePaymentGateway: Payment processing failed - $e');
      return false;
    }
  }

  @override
  Future<PaymentStatus> getPaymentStatus(String transactionId) async {
    print('StripePaymentGateway: Getting status for transaction $transactionId');
    try {
      final response = await _apiClient.get(
        'https://api.stripe.com/v1/charges/$transactionId',
        headers: {'Authorization': 'Bearer $_stripeApiKey'},
      );
      switch (response['status']) {
        case 'succeeded':
          return PaymentStatus.success;
        case 'pending':
          return PaymentStatus.pending;
        case 'failed':
          return PaymentStatus.failed;
        default:
          return PaymentStatus.unknown;
      }
    } catch (e) {
      print('StripePaymentGateway: Failed to get payment status - $e');
      return PaymentStatus.unknown;
    }
  }
}

Copy

// --- ドメインモデルの定義例 ---
class User {
  final String id;
  final String name;
  final String email;
  final DateTime createdAt;

  User({required this.id, required this.name, required this.email, required this.createdAt});

  @override
  String toString() {
    return 'User(id: $id, name: $name, email: $email, createdAt: $createdAt)';
  }
}

// --- 外部システム/データ層のモデル定義例 ---
// 1. ローカルDBのユーザー情報モデル
class LocalUserData {
  final String dbId;
  final String fullName;
  final String contactEmail;
  final int unixTimestamp; // Unixエポックからの秒数

  LocalUserData({required this.dbId, required this.fullName, required this.contactEmail, required required this.unixTimestamp});

  @override
  String toString() {
    return 'LocalUserData(dbId: $dbId, fullName: $fullName, contactEmail: $contactEmail, unixTimestamp: $unixTimestamp)';
  }
}

// 2. 外部APIのユーザー情報モデル
class ApiUserData {
  final String id;
  final String name;
  final String email;
  final String creationDate; // ISO 8601形式の文字列日付

  ApiUserData({required this.id, required this.name, required this.email, required this.creationDate});

  @override
  String toString() {
    return 'ApiUserData(id: $id, name: $name, email: $email, creationDate: $creationDate)';
  }
}

// --- Converterクラスの実装例 ---
class MultiSourceUserConverter {
  // LocalUserData を User ドメインモデルに変換
  User fromLocalData(LocalUserData localData) {
    print('Converting LocalUserData to User: $localData');
    return User(
      id: localData.dbId,
      name: localData.fullName,
      email: localData.contactEmail,
      createdAt: DateTime.fromMillisecondsSinceEpoch(localData.unixTimestamp * 1000), // 秒 -> ミリ秒
    );
  }

  // ApiUserData を User ドメインモデルに変換
  User fromApiData(ApiUserData apiData) {
    print('Converting ApiUserData to User: $apiData');
    return User(
      id: apiData.id,
      name: apiData.name,
      email: apiData.email,
      createdAt: DateTime.parse(apiData.creationDate), // 文字列日付をDateTimeにパース
    );
  }

  // User ドメインモデルを LocalUserData に変換
  LocalUserData toLocalData(User user) {
    print('Converting User to LocalUserData: $user');
    return LocalUserData(
      dbId: user.id,
      fullName: user.name,
      contactEmail: user.email,
      unixTimestamp: user.createdAt.millisecondsSinceEpoch ~/ 1000, // ミリ秒 -> 秒 (整数除算)
    );
  }

  // User ドメインモデルを ApiUserData に変換
  ApiUserData toApiData(User user) {
    print('Converting User to ApiUserData: $user');
    return ApiUserData(
      id: user.id,
      name: user.name,
      email: user.email,
      creationDate: user.createdAt.toIso8601String(), // DateTimeをISO 8601文字列に変換
    );
  }
}

Copy

// アプリケーション内部が期待する新しい支払いサービスインターフェース（ターゲット）
abstract class PaymentService {
  Future<bool> processPayment(double amount);
}

// 旧バージョンの決済SDKのAPI（アダプティ）
class OldPaymentSdk {
  int initiatePayment(int rawAmount) {
    // 旧SDKの決済処理を模倣
    print('OldPaymentSdk: 決済処理を開始します...');
    if (rawAmount > 0) {
      print('OldPaymentSdk: 決済成功コードを返します。');
      return 0; // 成功コード
    } else {
      print('OldPaymentSdk: 決済失敗コードを返します。');
      return -1; // 失敗コード
    }
  }

  void initializeSdk(String apiKey, String secretKey) {
    // SDKの初期化ロジック
    print('OldPaymentSdk: SDKを初期化します...');
  }
}

// OldPaymentSdkをPaymentServiceインターフェースに適合させるアダプター
class OldPaymentSdkAdapter implements PaymentService {
  final OldPaymentSdk _oldSdk; // 旧SDKのインスタンスへの依存
  static const double _currencyConversionRate = 100.0;

  OldPaymentSdkAdapter(this._oldSdk);

  void initialize(String apiKey, String secretKey) {
    _oldSdk.initializeSdk(apiKey, secretKey);
  }

  @override
  Future<bool> processPayment(double amount) async {
    // 新しいインターフェースのdouble型金額を、旧SDKが期待するint型に変換するロジック
    final int rawAmount = (amount * _currencyConversionRate).toInt();

    // 旧SDKのメソッドを呼び出し、その結果を新しいインターフェースの戻り値に変換
    final int sdkResult = _oldSdk.initiatePayment(rawAmount);

    // 成功コード（0）ならtrue、失敗コード（-1）ならfalseを返す
    if (sdkResult == 0) {
      print('OldPaymentSdkAdapter: 決済成功。');
      return true;
    } else {
      print('OldPaymentSdkAdapter: 決済失敗。');
      return false;
    }
  }
}

Copy

// --- ドメインモデルの定義例 ---
class User {
  final String id;
  final String name;
  final String email;

  User({required this.id, required this.name, required this.email});

  // JSONからUserオブジェクトを生成するファクトリコンストラクタ
  factory User.fromJson(Map<String, dynamic> json) {
    return User(
      id: json['id'] as String,
      name: json['name'] as String,
      email: json['email'] as String,
    );
  }

  // UserオブジェクトからJSONを生成するメソッド
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'name': name,
      'email': email,
    };
  }
}

// --- 抽象リポジトリの定義例 ---
abstract class UserRepository {
  Future<User> getUser(String userId);
  Future<List<User>> getAllUsers();
  Future<void> saveUser(User user);
  Future<void> deleteUser(String userId);
}

// --- 外部システムクライアントの抽象化 ---
abstract class ApiClient {
  Future<Map<String, dynamic>> get(String path);
  Future<Map<String, dynamic>> post(String path, Map<String, dynamic> data);
  Future<void> delete(String path);
}

// --- リポジトリの実装例 ---
class RemoteUserRepository implements UserRepository {
  final ApiClient _apiClient; // APIクライアントのインターフェースへの依存

  RemoteUserRepository(this._apiClient);

  @override
  Future<User> getUser(String userId) async {
    final response = await _apiClient.get('/users/$userId');
    return User.fromJson(response);
  }

  @override
  Future<List<User>> getAllUsers() async {
    final response = await _apiClient.get('/users');
    return (response['data'] as List).map((json) => User.fromJson(json)).toList();
  }

  @override
  Future<void> saveUser(User user) async {
    await _apiClient.post('/users', user.toJson());
  }

  @override
  Future<void> deleteUser(String userId) async {
    await _apiClient.delete('/users/$userId');
  }
}

Copy

// --- ドメインモデルの定義例 ---
class User {
  final String id;
  final String name;
  User({required this.id, required this.name});

  @override
  String toString() => 'User(id: $id, name: $name)';
}

// --- 抽象リポジトリの定義例 ---
abstract class UserRepository {
  Future<User> fetchUser(String id);
  Future<void> saveUser(User user);
}

// --- リポジトリの具体的な実装例 (モック) ---
class MockUserRepository implements UserRepository { ... }

// --- リポジトリの具体的な実装例 (リモート) ---
class RemoteUserRepository implements UserRepository { ... }

// --- Providerクラスの実装例 ---
// 実行環境に応じて適切なUserRepositoryの実装を提供するProvider
import 'package:flutter/foundation.dart'; // kDebugMode のために必要

class AppRepositoryProvider {
  static UserRepository getUserRepository() {
    if (kDebugMode) {
      print('AppRepositoryProvider: Providing MockUserRepository');
      return MockUserRepository();
    } else {
      print('AppRepositoryProvider: Providing RemoteUserRepository');
      return RemoteUserRepository();
    }
  }
}

Copy

// --- 状態クラスの定義 (ChangeNotifierをmixin) ---
class Counter with ChangeNotifier {
  int _count = 0;

  int get count => _count;

  void increment() {
    _count++;
    notifyListeners(); // 状態の変更をリスナーに通知
  }

  void decrement() {
    _count--;
    notifyListeners();
  }
}

// --- Providerを使用したアプリケーションのルートウィジェット例 ---
class MyAppWithProvider extends StatelessWidget {
  const MyAppWithProvider({super.key});

  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider( // Counterインスタンスをウィジェットツリーに提供
      create: (context) => Counter(), // Counterのインスタンスを生成
      child: MaterialApp(
        title: 'Provider Demo',
        home: CounterScreen(),
      ),
    );
  }
}

// --- 状態を利用するUIウィジェット例 ---
class CounterScreen extends StatelessWidget {
  const CounterScreen({super.key});

  @override
  Widget build(BuildContext context) {
    // Provider.of<Counter>(context) を使って上位のProviderからCounterインスタンスを取得
    final counter = Provider.of<Counter>(context);
    return Scaffold( ... );
  }
}

Copy

// --- 解決されるサービスのインターフェースと実装例 ---
abstract class AnalyticsService {
  void trackEvent(String eventName);
}

class FirebaseAnalyticsService implements AnalyticsService { ... }

class MockAnalyticsService implements AnalyticsService { ... }

// --- DependencyResolverクラスの実装例 ---
class DependencyResolver {
  final Map<Type, Object Function()> _factories = {};
  final Map<Type, Object> _singletons = {};
  final bool _useMocks;

  DependencyResolver({bool useMocks = false}) : _useMocks = useMocks {
    _registerDependencies();
  }

  void _registerDependencies() {
    // AnalyticsServiceの解決ロジックを登録
    if (_useMocks) {
      registerSingleton<AnalyticsService>(MockAnalyticsService());
    } else {
      registerFactory<AnalyticsService>(() => FirebaseAnalyticsService());
    }
    // 他の依存関係も同様に登録...
  }

  void registerFactory<T extends Object>(T Function() factory) {
    _factories[T] = factory;
  }

  void registerSingleton<T extends Object>(T instance) {
    _singletons[T] = instance;
  }

  T resolve<T extends Object>() {
    // まずシングルトンキャッシュを確認
    if (_singletons.containsKey(T)) {
      return _singletons[T] as T;
    }
    // 次にファクトリを確認
    if (_factories.containsKey(T)) {
      final instance = _factories[T]!() as T;
      return instance;
    }
    // どちらにも登録されていなければエラー
    throw Exception('Type $T not registered.');
  }
}

Copy

// --- 環境定義と設定インターフェース ---
enum AppEnvironment { development, staging, production }

abstract class ApiConfiguration {
  String get baseUrl;
  String get apiKey;
  Duration get timeout;
}

// --- 各環境向けの設定実装例 ---
class DevelopmentApiConfiguration implements ApiConfiguration { ... }

class StagingApiConfiguration implements ApiConfiguration { ... }

class ProductionApiConfiguration implements ApiConfiguration { ... }

// --- ConfigurationResolverクラスの実装例 ---
class ConfigurationResolver {
  final AppEnvironment _currentEnvironment;

  ConfigurationResolver(this._currentEnvironment);

  /// 現在の環境に基づいてAPI設定を解決します。
  ApiConfiguration resolveApiConfiguration() {
    switch (_currentEnvironment) {
      case AppEnvironment.development:
        return DevelopmentApiConfiguration();
      case AppEnvironment.production:
        return ProductionApiConfiguration();
      case AppEnvironment.staging:
        return StagingApiConfiguration();
    }
  }

  /// 指定された機能フラグの現在の状態を解決します。
  bool resolveFeatureFlag(String flagName) {
    print('ConfigurationResolver: Resolving feature flag "$flagName"...');
    // 機能フラグを解決するロジック
    if (_currentEnvironment == AppEnvironment.development &&
        flagName == 'newAwesomeFeature') {
      print(
        'ConfigurationResolver: Feature "$flagName" is ENABLED for development.',
      );
      return true;
    }
    if (flagName == 'betaFeature' &&
        (_currentEnvironment == AppEnvironment.staging ||
            _currentEnvironment == AppEnvironment.development)) {
      print(
        'ConfigurationResolver: Feature "$flagName" is ENABLED for staging/development.',
      );
      return true;
    }
    print('ConfigurationResolver: Feature "$flagName" is DISABLED.');
    return false; // デフォルトは無効
  }
}

Copy

// --- 通知ペイロードのデータモデル ---
class NotificationPayload {
  final String type;
  final Map<String, dynamic> data;

  NotificationPayload({required this.type, required this.data});

  @override
  String toString() => 'NotificationPayload(type: $type, data: $data)';
}

// --- ハンドラーが依存するサービスのインターフェース例 ---
abstract class NavigationService {
  void navigateToProduct(String productId);
  void navigateToUserProfile(String userId);
  void showGeneralAlert(String title, String message);
}

// --- NavigationServiceの実装例 ---
class AppNavigationService implements NavigationService { ... }

// --- NotificationHandlerクラスの実装例 ---
class NotificationHandler {
  final NavigationService _navigationService;

  NotificationHandler(this._navigationService);

  /// 受信した通知ペイロードを処理します。
  void handleNotification(NotificationPayload payload) {
    print('NotificationHandler: Received notification of type "${payload.type}" with data: ${payload.data}');

    switch (payload.type) {
      case 'deep_link_product':
        final productId = payload.data['productId'] as String?;
        if (productId != null) {
          _navigationService.navigateToProduct(productId);
        } else {
          print('NotificationHandler: Error - Product ID missing in deep_link_product payload.');
        }
        break;
      case 'deep_link_user_profile':
        final userId = payload.data['userId'] as String?;
        if (userId != null) {
          _navigationService.navigateToUserProfile(userId);
        } else {
          print('NotificationHandler: Error - User ID missing in deep_link_user_profile payload.');
        }
        break;
      case 'simple_alert':
        final title = payload.data['title'] as String? ?? 'Notification';
        final message = payload.data['message'] as String? ?? 'You have a new notification.';
        _navigationService.showGeneralAlert(title, message);
        break;
      default:
        print('NotificationHandler: Unhandled notification type: ${payload.type}');
    }
  }
}

Copy

// --- ドメインモデルの定義例 ---
class Order {
  final String id;
  final List<OrderItem> items;
  final double totalAmount;
  Order({required this.id, required this.items, required this.totalAmount});

  @override
  String toString() => 'Order(id: $id, totalAmount: $totalAmount, items: ${items.length})';
}

class OrderItem {
  final String productId;
  final int quantity;
  final double price;
  OrderItem({required this.productId, required this.quantity, required this.price});

  @override
  String toString() => 'OrderItem(productId: $productId, quantity: $quantity)';
}

class Product {
  final String id;
  final String name;
  int stock;
  Product({required this.id, required this.name, required this.stock});

  @override
  String toString() => 'Product(id: $id, name: $name, stock: $stock)';
}

// --- 依存するインターフェースの定義例 ---
// 注文データ永続化のリポジトリ
abstract class OrderRepository {
  Future<void> saveOrder(Order order);
}

// 商品データアクセスと在庫更新のリポジトリ
abstract class ProductRepository {
  Future<Product> getProduct(String productId);
  Future<void> updateStock(String productId, int quantityChange); // quantityChangeは増減値
}

// 支払い処理を担うゲートウェイ
abstract class PaymentGateway {
  Future<bool> processPayment(double amount);
}

// --- Serviceインターフェースの定義例 ---
// 注文処理の複雑なビジネスプロセスを担うサービスの抽象インターフェース
abstract class OrderProcessingService {
  Future<void> placeOrder(Order order);
}

// --- Serviceインターフェースの実装例 ---
// OrderProcessingServiceインターフェースの具体的な実装クラス
class OrderProcessingServiceImpl implements OrderProcessingService {
  final OrderRepository _orderRepository;
  final ProductRepository _productRepository;
  final PaymentGateway _paymentGateway;

  // コンストラクタによる依存性注入
  OrderProcessingService(
    this._orderRepository,
    this._productRepository,
    this._paymentGateway,
  );

  // 注文処理のメインロジック
  Future<void> placeOrder(Order order) async {
    print('--- OrderProcessingService: 注文処理を開始します ---');

    // 1. 在庫確認: 商品ごとに在庫を確認
    for (var item in order.items) {
      final product = await _productRepository.getProduct(item.productId);
      if (product.stock < item.quantity) {
        throw Exception('在庫が不足しています: ${product.name} (現在の在庫: ${product.stock}, 要求数: ${item.quantity})');
      }
    }
    print('OrderProcessingService: 在庫確認完了。');

    // 2. 支払い処理: 外部の支払いゲートウェイを利用
    final success = await _paymentGateway.processPayment(order.totalAmount);
    if (!success) {
      throw Exception('支払い処理に失敗しました');
    }
    print('OrderProcessingService: 支払い処理完了。');

    // 3. 注文の保存: 注文リポジトリを利用
    await _orderRepository.saveOrder(order);
    print('OrderProcessingService: 注文情報保存完了。');

    // 4. 在庫の更新: 商品リポジトリを利用
    for (var item in order.items) {
      await _productRepository.updateStock(item.productId, -item.quantity);
    }
    print('OrderProcessingService: 在庫更新完了。');

    print('--- OrderProcessingService: 注文処理が正常に完了しました！ ---');
  }
}

Copy

// --- ドメインモデルの定義例 ---
class Cart {
  final String userId;
  final List<CartItem> items;
  double get total => items.fold(0.0, (sum, item) => sum + (item.price * item.quantity));

  Cart({required this.userId, required this.items});

  @override
  String toString() => 'Cart(userId: $userId, items: ${items.length}, total: $total)';
}

class CartItem {
  final String productId;
  final int quantity;
  final double price;

  CartItem({required this.productId, required this.quantity, required this.price});

  @override
  String toString() => 'CartItem(productId: $productId, quantity: $quantity, price: $price)';
}

class Order {
  final String id;
  final String userId;
  final List<OrderItem> items;
  final double totalAmount;

  Order({required this.id, required this.userId, required this.items, required this.totalAmount});

  @override
  String toString() => 'Order(id: $id, userId: $userId, items: ${items.length}, totalAmount: $totalAmount)';
}

class OrderItem {
  final String productId;
  final int quantity;
  final double price;

  OrderItem({required this.productId, required this.quantity, required this.price});

  @override
  String toString() => 'OrderItem(productId: $productId, quantity: $quantity, price: $price)';
}

// --- 依存するインターフェースの定義例 ---
// 注文処理の複雑なビジネスプロセスを担うサービス
abstract class OrderProcessingService {
  Future<void> placeOrder(Order order);
}

// カートデータの永続化と取得を担うリポジトリ
abstract class CartRepository {
  Future<Cart> getCart(String userId);
  Future<void> clearCart(String userId);
  Future<void> addItemToCart(String userId, CartItem item); // カートへの商品追加メソッド（例として）
}

// --- UseCaseクラスの実装例 ---
class PlaceOrderFromCartUseCase {
  final CartRepository _cartRepository;
  final OrderProcessingService _orderProcessingService; // Serviceへの依存

  PlaceOrderFromCartUseCase(this._cartRepository, this._orderProcessingService);

  Future<void> execute(String userId) async {
    print('--- PlaceOrderFromCartUseCase: ユーザー $userId の注文処理を開始します。 ---');

    // 1. ユーザーのカートを取得する
    final cart = await _cartRepository.getCart(userId);
    if (cart.items.isEmpty) {
      print('PlaceOrderFromCartUseCase: カートに商品がありません。処理を中断します。');
      throw Exception('カートに商品がありません。');
    }
    print('PlaceOrderFromCartUseCase: カート情報を取得しました: $cart');

    // 2. カートの内容から新しい注文オブジェクトを作成する（UseCase固有のドメインロジックの一部）
    // このような変換ロジックは、より複雑な場合は専用のConverterやFactoryに移譲することも検討
    final newOrder = Order(
      id: 'ORDER-${DateTime.now().millisecondsSinceEpoch}-${userId.substring(0,3)}', // ユニークなIDを生成（例）
      userId: userId,
      items: cart.items.map((cartItem) => OrderItem(
            productId: cartItem.productId,
            quantity: cartItem.quantity,
            price: cartItem.price,
          )).toList(),
      totalAmount: cart.total,
    );
    print('PlaceOrderFromCartUseCase: 注文オブジェクトを作成しました: $newOrder');

    // 3. 注文処理サービスを呼び出し、複雑なビジネスプロセスを委譲する
    await _orderProcessingService.placeOrder(newOrder);
    print('PlaceOrderFromCartUseCase: OrderProcessingServiceによる注文処理が完了しました。');

    // 4. 注文成功後の後続処理（ユースケースの完了ロジック）
    await _cartRepository.clearCart(userId);
    print('PlaceOrderFromCartUseCase: ユーザー $userId のカートがクリアされました。');

    print('--- PlaceOrderFromCartUseCase: 注文が正常に完了しました！ ---');
  }
}

Copy

// --- 依存するサービスやモデルのインターフェース/クラス定義 ---
abstract class AuthenticationService {
  Future<String?> login(String email, String password); // トークンまたはnullを返す
  Future<void> logout(String token);
  Future<User?> getUserProfileFromToken(String token);
}

class User {
  final String id;
  final String name;
  final String email;

  User({required this.id, required this.name, required this.email});

  @override
  String toString() => 'User(id: $id, name: "$name", email: "$email")';
}

// セキュアストレージサービスのインターフェース
abstract class SecureStorageService {
  Future<String?> readToken();
  Future<void> saveToken(String token);
  Future<void> deleteToken();
}

// --- SessionManagerクラスの実装例 ---
class SessionManager extends ChangeNotifier {
  final AuthenticationService _authService;
  final SecureStorageService _secureStorage; // トークン永続化用

  User? _currentUser;
  String? _sessionToken;
  bool _isLoading = false;
  bool _isInitialized = false;

  User? get currentUser => _currentUser;
  String? get sessionToken => _sessionToken;
  bool get isLoading => _isLoading;
  bool get isLoggedIn => _currentUser != null && _sessionToken != null;
  bool get isInitialized => _isInitialized;


  SessionManager(this._authService ,this._secureStorage);

  /// アプリケーション起動時などに呼び出し、永続化されたセッションの復元を試みます。
  Future<void> initializeSession() async {
    if (_isInitialized) return; // 既に初期化済みなら何もしない

    _setLoading(true);
    String? storedToken = await _secureStorage.readToken(); // ストレージからトークンを読み込む

    if (storedToken != null) {
      try {
        final userProfile = await _authService.getUserProfileFromToken(storedToken);
        if (userProfile != null) {
          _currentUser = userProfile;
          _sessionToken = storedToken;
          print('SessionManager: Session restored for user ${userProfile.name}.');
        } else {
          // トークンが無効だった場合
          await _secureStorage.deleteToken();
        }
      } catch (e) {
        print('SessionManager: Error restoring session - $e');
        await _secureStorage.deleteToken(); // エラー時もトークンを削除
      }
    }
    _isInitialized = true;
    _setLoading(false);
    print('SessionManager: Session initialization complete. Logged in: $isLoggedIn');
    notifyListeners(); // 初期化完了を通知
  }

  /// ユーザーをログインさせ、セッションを開始します。
  Future<bool> login(String email, String password) async {
    if (isLoggedIn) return true; // 既にログイン済み

    _setLoading(true);
    try {
      final token = await _authService.login(email, password);
      if (token != null) {
        final userProfile = await _authService.getUserProfileFromToken(token);
        if (userProfile != null) {
          _currentUser = userProfile;
          _sessionToken = token;
          await _secureStorage.saveToken(token); // トークンを永続化
          print('SessionManager: User ${_currentUser!.name} logged in successfully.');
          _setLoading(false);
          notifyListeners(); // 状態変更を通知
          return true;
        }
      }
      _clearSessionInternal(); // ログイン失敗時はセッション情報をクリア
      _setLoading(false);
      notifyListeners();
      return false;
    } catch (e) {
      print('SessionManager: Login attempt failed - $e');
      _clearSessionInternal();
      _setLoading(false);
      notifyListeners();
      return false;
    }
  }

  /// 現在のユーザーをログアウトさせ、セッションを終了します。
  Future<void> logout() async {
    if (!isLoggedIn) return;

    _setLoading(true);
    print('SessionManager: Logging out user ${_currentUser?.name ?? ""}...');
    if (_sessionToken != null) {
      try {
        await _authService.logout(_sessionToken!); // バックエンドでのログアウト処理
      } catch (e) {
        print('SessionManager: Error during backend logout - $e (proceeding with local logout)');
      }
    }
    _clearSessionInternal();
    await _secureStorage.deleteToken(); // 永続化されたトークンを削除
    _setLoading(false);
    print('SessionManager: User logged out.');
    notifyListeners(); // 状態変更を通知
  }

  /// 内部的にセッション情報をクリアします (通知は別途行う)。
  void _clearSessionInternal() {
    _currentUser = null;
    _sessionToken = null;
  }

  /// ローディング状態を設定し、リスナーに通知します。
  void _setLoading(bool loading) {
    if (_isLoading != loading) {
      _isLoading = loading;
      notifyListeners(); // ローディング状態の変更を通知
    }
  }
}

Copy