E2EEChat/lib/common/api.dart

import 'dart:convert';
import 'dart:io';
import 'package:web_socket_channel/io.dart';
import 'package:web_socket_channel/web_socket_channel.dart';
import 'package:web_socket_channel/status.dart' as status;

import 'package:cookie_jar/cookie_jar.dart';
import 'package:crypto/crypto.dart';
import 'package:dio/adapter.dart';
import 'package:dio/dio.dart';
import 'package:dio_cookie_manager/dio_cookie_manager.dart';
import 'package:e2ee_chat/common/global.dart';


class Api {
  Api();

  static final Dio dio = Dio(BaseOptions(
    baseUrl: 'http://mechat.shellmiao.com/',
  ));

  static String WebSocketUrl='ws://mechat.shellmiao.com/infrastructure/ws/${Global.profile.username}/';



  static final cookieJar = CookieJar();

  static init() async {
    if (!Global.isRelease && false) {
      (dio.httpClientAdapter as DefaultHttpClientAdapter).onHttpClientCreate = (client) {
        /*
        client.findProxy = (uri) {
          return "PROXY 10.122.237.112:8080";
        };
         */
        //代理工具会提供一个抓包的自签名证书，会通不过证书校验，所以我们禁用证书校验
        client.badCertificateCallback = (X509Certificate cert, String host, int port) => true;
      };
    }

    dio.interceptors.add(CookieManager(cookieJar));

    try {
      await dio.get('/account/login/');
      debug(await Dio().get('https://baidu.com/'));
      // await Dio().get('http://10.122.237.112/account/login/');
    } on DioError catch(e) {
      debug('Api init connect to server failed!');
    }
  }

  Future<String?> login({required String username, String? password, String? token}) async {
    debug('Api login begin');
    String _password = "";
    String? _token;
    if (password != null) {
      var bytes = utf8.encode(password);
      var digest = sha1.convert(bytes);
      _password = digest.toString();
    }
    var data = {"username": username, "token": token ?? Global.emptyToken, "password": password};
    debug('Api login data: $data');
    try {
      var r = await dio.post(
        "/account/login/", data: FormData.fromMap(data),
        // options: _options,
      );
      // debug('Api login response: $r');
      var json = jsonDecode(r.data);
      _token = json["token"].toString();
      debug('Api login new token: $_token');
    } on DioError catch (e) {
      var data = e.response?.data;
      var status = e.response?.statusCode;
      debug('Api login error, statusCode: $status, data: $data');
      throw e;
    }
    debug('Api login end');
    return _token;
  }

  Future<bool> logout() async {
    debug('Api logout begin');
    bool _result = true;
    try {
      await dio.post("/account/logout/");
    } on DioError catch (e) {
      _result = false;
    }
    debug('Api logout end');
    return _result;
  }

  Future<bool> register(String username, String password) async {
    debug('Api register begin');
    bool _result = true;
    try {
      var data = {"username": username, "password": password, "password2": password};
      await dio.post('/account/register/', data: FormData.fromMap(data));
    } on DioError catch (e) {
      _result = false;
    }
    debug('Api register end');
    return _result;
  }

  Future<bool> edit({String? bio, File? avatar, String? phone}) async {
    debug('Api edit begin');
    bool _result = Global.profile.isLogin;
    if (_result) {
      try {
        Map<String, dynamic> data = {"bio": bio, "phone": phone};
        if (avatar != null) {
          var path = avatar.path;
          var name = path.substring(path.lastIndexOf("/") + 1, path.length);
          data["file"] = await MultipartFile.fromFile(path, filename: name);
        }
        var form = FormData.fromMap(data);
        await dio.post('/account/edit/${Global.profile.username}/', data: form);
      } on DioError catch (e) {
        _result = false;
      }
    }
    debug('Api edit end');
    return _result;
  }

  Future<Map<String, dynamic>?> userProfile(String username) async {
    debug('Api get user profile begin');
    Map<String, dynamic>? _result;
    try {
      var r = await dio.post('/account/profile/$username');
      _result = json.decode(r.data);
    } catch (e) {
      debug('get user profile failed!');
    }
    debug('Api get user profile end');
    return _result;
}

  List<String> listStringFromJson(String s) {
    final list = <String>[];
    for (var i in jsonDecode(s) as List<dynamic>) {
      list.add(i.toString());
    }
    return list;
  }

  Future<List<String>?> friendList() async {
    debug('Api friendList begin');
    List<String>? friends;
    try {
      var r = await dio.post('/friends/friends_list/');
      friends = listStringFromJson(r.data);
      debug('Api friendList get: $friends');
    } on DioError catch (e) {
      debug('get friend list failed: ${e.response?.statusCode ?? "unknown"}');
    } catch(e) {
      debug('Api get friend list failed: $e');
    }
    debug('Api friendList end');
    return friends;
  }

  Future<bool> addFriend(String username) async {
    debug("add friend begin: add $username");
    bool _result = true;
    try {
      await dio.post('/friends/add/', data: FormData.fromMap({"username": username}));
    } on DioError catch (e) {
      _result = false;
      debug("add friend failed: ${ () {
        switch (e.response?.statusCode) {
          case null: return "unknown error";
          case 421: return "already friend";
          case 422:case 400: return "failed";
        }
      } ()}");
    }
    debug("add friend end");
    return _result;
  }

  Future<bool> acceptFriend(String username) async {
    debug("accept friend begin");
    bool _result = true;
    try {
      await dio.post('/friends/accept/', data: FormData.fromMap({"username": username}));
    } on DioError catch (e) {
      debug("accept friend failed");
      _result = false;
    }
    debug("accept friend end");
    return _result;
  }

  Future<bool> refuseFriend(String username) async {
    debug("refuse friend begin");
    bool _result = true;
    try {
      await dio.post('/friends/refuse/', data: FormData.fromMap({"username": username}));
    } on DioError catch (e) {
      _result = false;
      debug("refuse friend failed: ${ () {
        switch (e.response?.statusCode) {
          case null: return "unknown error";
          case 424: return "no add requests";
          case 400: return "failed";
        }
      } ()}");
    }
    debug("refuse friend end");
    return _result;
  }

  Future<List<String>?> friendRequest() async {
    debug('Api friendRequest begin');
    List<String>? apps;
    try {
      var r = await dio.post('/friends/get_requests/');
      apps = listStringFromJson(r.data);
    } on DioError catch (e) {
      debug('get friend request failed!');
    }
    debug('Api friendRequest end');
    return apps;
  }

  Future<bool> deleteFriend(String username) async {
    debug("delete friend begin");
    bool _result = true;
    try {
      await dio.post('/friends/delete/', data: FormData.fromMap({"username": username}));
    } on DioError catch (e) {
      debug("delete friend failed: ${ () {
        switch (e.response?.statusCode) {
          case null: return "unknown error";
          case 422:case 400: return "failed";
        }
      } ()}");
      _result = false;
    }
    debug("delete friend end");
    return _result;
  }

  Future<bool> addPublicKey(String publicKey) async {
    debug("add public key begin");
    bool _result = true;
    try {
      await dio.post('/infrastructure/add_public_key', data: FormData.fromMap({"public_key": publicKey}));
    } on DioError catch (e) {
      debug("add public key failed: ${ () {
        switch (e.response?.statusCode) {
          case null: return "unknown error";
          case 400: return "failed";
        }
      } ()}");
      _result = false;
    }
    debug("add public key end");
    return _result;
  }

  Future<List<String>?> getPublicKey(String username) async {
    debug("get public key begin");
    List<String>? publicKeys;
    try {
      var r=await dio.post('/infrastructure/get_public_key/', data: FormData.fromMap({"username": username}));
      publicKeys = listStringFromJson(r.data);
    } on DioError catch (e) {
      debug("get public key failed: ${ () {
        switch (e.response?.statusCode) {
          case null: return "unknown error";
          case 400: return "failed";
        }
      } ()}");
    }
    debug("get public key end");
    return publicKeys;
  }
  Future<bool> sendMessage(String username,String plaintext) async {
    debug("send message begin: username=$username, plaintext=$plaintext");
    bool _result = true;
    try {
      await dio.post('/chat/send/', data: FormData.fromMap({"toUsername": username,"plaintext":plaintext}));
    } on DioError catch (e) {
      debug("send message failed: ${ () {
        switch (e.response?.statusCode) {
          case null: return "unknown error";
          case 400: return "failed";
          case 422: return "the user does not exist";
          case 423: return "you are not friends";
          default: return e;
        }
      } ()}");
      _result = false;
    }
    debug("send message end");
    return _result;
  }

  Future<List<String>?> getFilterMessages(String username) async {
    debug("get filter message begin: username=$username");
    List<String>? messages;
    try {
      var r=await dio.post('/chat/filter_message/', data: FormData.fromMap({"username": username}));
      messages = listStringFromJson(r.data);
      debug("get filter message: messages=$messages");
    } on DioError catch (e) {
      debug("get filter messages failed: ${ () {
        switch (e.response?.statusCode) {
          case null: return "unknown error";
          case 400: return "failed";
          case 422: return "the user does not exist";
          case 423: return "you are not friends";
        }
      } ()}");
    }
    debug("get filter messages end");
    return messages;
  }

  Future<List<String>?> getLastMessages(String username) async {
    debug("get last messages begin");
    List<String>? messages;
    try {
      var r=await dio.post('/chat/request_message/');
      messages = listStringFromJson(r.data);
    } on DioError catch (e) {
      debug("add public key failed: ${ () {
        switch (e.response?.statusCode) {
          case null: return "unknown error";
        }
      } ()}");
    }
    debug("get last messages end");
    return messages;
  }

  Future<bool> receivedSuccessfully(String message_id) async {
    debug("received successfully begin");
    bool _result = true;
    try {
      await dio.post('/chat/receive_successfully', data: FormData.fromMap({"message_id": message_id}));
    } on DioError catch (e) {
      debug("received successfully failed: ${ () {
        switch (e.response?.statusCode) {
          case null: return "unknown error";
          case 400: return "failed";
          case 423: return "the message does not exist";
        }
      } ()}");
    }
    debug("received successfully end");
    return _result;
  }

 void connectWebSocket() {
    debug("delete friend begin");
    final channel=IOWebSocketChannel.connect(WebSocketUrl);
    channel.stream.listen((message) {
      return message;
    });//如果message是request_message,则请求消息；如果是get_friends_requests,则请求好友
  }
}