rog_app/lib/services/auth_service.dart

import 'dart:convert';
import 'package:http/http.dart' as http;
import 'package:gifunavi/model/auth_user.dart';
import 'package:get/get.dart';
import 'package:flutter/material.dart';

import '../utils/const.dart';
//import 'package:rogapp/services/team_service.dart';
//import 'package:rogapp/services/member_service.dart';


class AuthService {
  Future<AuthUser?> userLogin(String email, String password) async {
    final serverUrl = ConstValues.currentServer();
    final url = '$serverUrl/api/login/';

    try {
      final http.Response response = await http.post(
        Uri.parse(url),
        headers: <String, String>{
          'Content-Type': 'application/json; charset=UTF-8',
        },
        body:
            jsonEncode(<String, String>{'email': email, 'password': password}),
      );
      switch (response.statusCode) {
        case 200:
          final data = json.decode(utf8.decode(response.bodyBytes));
          AuthUser user = AuthUser.fromMap(data["user"]);
          final String token = data["token"];
          user.auth_token = token;
          return user;
        default:
          return null;
        //throw Exception(response.reasonPhrase);
      }
    } on Exception catch (_) {
      rethrow;
    }
  }

  Future<AuthUser?> userFromToken(String token) async {
    final serverUrl = ConstValues.currentServer();
    final url = '$serverUrl/api/user/';
    try {
      final http.Response response =
          await http.get(Uri.parse(url), headers: <String, String>{
        'Content-Type': 'application/json; charset=UTF-8',
        'Authorization': 'Token $token'
      });
      switch (response.statusCode) {
        case 200:
          final data = json.decode(utf8.decode(response.bodyBytes));
          AuthUser user = AuthUser.fromMap(data);
          user.auth_token = token;
          return user;
        default:
          return null;
        //throw Exception(response.reasonPhrase);
      }
    } on Exception catch (_) {
      rethrow;
    }
  }

  static Future<Map<String, dynamic>> changePassword(
      String oldpassword, String newpassword, String token) async {
    Map<String, dynamic> changePassword = {};
    String serverUrl = ConstValues.currentServer();
    String url = '$serverUrl/api/change-password/';
    //print('++++++++$url');
    final http.Response response = await http.put(
      Uri.parse(url),
      headers: <String, String>{
        'Content-Type': 'application/json; charset=UTF-8',
        'Authorization': 'Token $token'
      },
      body: jsonEncode(<String, String>{
        'old_password': oldpassword,
        'new_password': newpassword
      }),
    );

    if (response.statusCode == 200) {
      changePassword = json.decode(utf8.decode(response.bodyBytes));
    }
    return changePassword;
  }

  static Future<Map<String, dynamic>> login(String email, String password) async {
    //print("------- in logged email $email pwd $password ###### --------");
    Map<String, dynamic> cats = {};
    String serverUrl = ConstValues.currentServer();
    String url = '$serverUrl/api/login/';
    //print('++++++++$url');
    //String url = 'http://localhost:8100/api/login/';
    try {
      final http.Response response = await http.post(
        Uri.parse(url),
        headers: <String, String>{
          'Content-Type': 'application/json; charset=UTF-8',
        },
        body: jsonEncode(
            <String, String>{'email': email, 'password': password}),
      );

      if (response.statusCode == 200) {
        cats = json.decode(utf8.decode(response.bodyBytes));
      } else {
        debugPrint('Response body: ${response.body}');

        print('Login failed with status code: ${response.statusCode}');
        var errorMessage = 'ログインに失敗しました。';
        if (response.statusCode == 400) {
          var errorBody = json.decode(utf8.decode(response.bodyBytes));
          errorMessage = errorBody['non_field_errors']?[0] ?? 'パスワードが正しくありません。';
        }
        throw Exception(errorMessage);
      }
    } catch( e ){
      print('Error in login: $e');
      throw e;  // エラーを上位に伝播させる
      /*
      print('Error in login: $e');
      Get.snackbar("通信エラーがおきました", "サーバーと通信できませんでした",
          backgroundColor: Colors.red,
          colorText: Colors.white);
      Get.snackbar(
        "通信エラーがおきました",
        "サーバーと通信できませんでした",
          backgroundColor: Colors.red,
          colorText: Colors.white,
        icon: const Icon(
            Icons.assistant_photo_outlined, size: 40.0, color: Colors.blue),
        snackPosition: SnackPosition.TOP,
        duration: const Duration(seconds: 3),
        //backgroundColor: Colors.yellow,
      );
       */
      //cats = {};
    }
    return cats;
  }


  // ユーザー登録
  //
  /*
  Future<void> registerUser(String email, String password, bool isFemale) async {
    final user = await register(email, password);
    if (user != null) {
      final _teamController = TeamController();
      _teamController.createTeam(String teamName, int categoryId) ;
      final teamService = TeamService();
      final memberService = MemberService();

      final team = await teamService.createSoloTeam(user.id, isFemale);
      await memberService.addMember(team.id, user.id);
    }
  }

   */

  static Future<Map<String, dynamic>> register(
      String email, String password, String password2) async {
    Map<String, dynamic> cats = {};
    String serverUrl = ConstValues.currentServer();
    String url = '$serverUrl/api/register/';
    //debugPrint('++++++++$url');
    final http.Response response = await http.post(
      Uri.parse(url),
      headers: <String, String>{
        'Content-Type': 'application/json; charset=UTF-8',
      },
      body: jsonEncode(<String, String>{'email': email, 'password': password, 'password2': password2}),
    );
    cats = json.decode(utf8.decode(response.bodyBytes));
    print("result=$cats");
    if (response.statusCode == 201) {
    }else{
    }
    return cats;
  }

  static Future<Map<String, dynamic>> deleteUser(String token) async {
    Map<String, dynamic> cats = {};
    String serverUrl = ConstValues.currentServer();
    String url = '$serverUrl/api/delete-account/';
    //print('++++++++$url');
    final http.Response response =
        await http.get(Uri.parse(url), headers: <String, String>{
      'Content-Type': 'application/json; charset=UTF-8',
      'Authorization': 'Token $token'
    });

    if (response.statusCode == 200) {
      cats = json.decode(utf8.decode(response.bodyBytes));
    }
    return cats;
  }


  static Future<List<dynamic>?> userDetails(int userid) async {
    List<dynamic> cats = [];
    String serverUrl = ConstValues.currentServer();
    String url = '$serverUrl/api/userdetials?user_id=$userid';
    //print('++++++++$url');
    //print("---- UserDetails url is $url");
    final response = await http.get(
      Uri.parse(url),
      headers: <String, String>{
        'Content-Type': 'application/json; charset=UTF-8',
      },
    );

    if (response.statusCode == 200) {
      cats = json.decode(utf8.decode(response.bodyBytes));
    }
    return cats;
  }

  static Future<List<dynamic>?> userForToken(String token) async {
    Map<String, dynamic> cats = {};
    String serverUrl = ConstValues.currentServer();
    String url = '$serverUrl/api/user/';
    //print('++++++++$url');
    //print("---- UserDetails url is $url");
    final response = await http.get(
      Uri.parse(url),
      headers: <String, String>{
        'Content-Type': 'application/json; charset=UTF-8',
        'Authorization': 'Token $token'
      },
    );

    if (response.statusCode == 200) {
      cats = json.decode(utf8.decode(response.bodyBytes));
      //print("--- eeeeee $cats ----");
    }
    return [
      {"user": cats, "token": token}
    ];
  }
}