[GROOMING] Contact synchonization v2

[hoangdat]

Desc:

• ADR: https://www.notion.so/linagora/ADR-Contact-Sync-in-TWP-34b87eca754d4614ad9d9a050a1cd956

DoD:

• Synchronize contact to web app

[hoangdat]

• hashDetails: n peppers

{
  "algorithms": [
    "none",
    "sha256"
  ],
  "lookup_pepper": "matrixrocks",
  "alt_lookup_peppers": ["oldmatrixrocks"]
}

• 1 pid <-> n hash: Map<String, List<String>: map between pid to each hash of this

[hoangdat]

class ThirdPartyLookupAPI {
  Future<Response> lookup(baseUrl, accessToken, List<CalculatedHash>) {
    // create + setup dio
    // get response from thirdparty 
  }
}

[hoangdat]

https://www.notion.so/linagora/ADR-Contact-Synching-34b87eca754d4614ad9d9a050a1cd956?d=14562718bad1806c814b001c8e0ab4b8#13f62718bad1805d93bdfc0eab90d78e

[hoangdat]

1. How to extract Fed server in well-known?
2. How Contact Manager work in case Fed available, or not?
3. How to work with Fed server?

• how to get token for Fed server?
• how to handle this token when it is expired?

4. How to get /hash_details in Fed?
5. How to fetch /look_up in Fed?
6. How to handle mappings in /look_up response?
7. How to handle third_party_mappings in /look_up response?

[nqhhdev]

How to extract Fed server in well-know

• ENDPOINT {{homeserver}}.well-known/matrix/client

• Response

{
    ...
    "m.federated_identity_services": {
        "base_urls": [
            "https://fed...com/"
        ]
    },
    ...
}

Create Fed server info:

@JsonSerializable()
class FedServerInformation with EquatableMixin {
  static const String fedServerKey = 'm.federated_identity_services';

  @JsonKey(name: 'base_url')
  final Uri? baseUrl;

  @JsonKey(name: 'server_name')
  final String? serverName;

  FedServerInformation({
    this.baseUrl,
    this.serverName,
  });

  factory FedServerInformation.fromJson(Map<String, dynamic> json) =>
      _$FedServerInformationFromJson(json);

  Map<String, dynamic> toJson() => _$FedServerInformationToJson(this);

  @override
  List<Object?> get props => [baseUrl, serverName];
}

Create FedConfigurations

class FedConfigurations with EquatableMixin {
  final FedServerInformation fedServerInformation;
  final IdentityServerInformation? identityServerInformation;
  final String? authUrl;
  final LoginType? loginType;

  FedConfigurations({
    required this.tomServerInformation,
    this.identityServerInformation,
    this.authUrl,
    this.loginType,
  });

  @override
  List<Object?> get props =>
      [fedServerInformation, identityServerInformation, authUrl, loginType];
}

Convert response from .well-know to FedServerInformation

• Write func convert it in HomeserverSummaryExtensions: lib/domain/model/extensions/homeserver_summary_extensions.dart

FedServerInformation? get fedServer {
    if (discoveryInformation?.additionalProperties == null) {
      return null;
    }
    final fedServerJson = discoveryInformation
        ?.additionalProperties[FedServerInformation.fedServerKey];
    if (fedServerJson == null) {
      return null;
    }
    try {
      return FedServerInformation.fromJson(fedServerJson);
    } catch (e) {
      Logs().e('Failed to parse m.federated_identity_services from homeserver summary', e);
      return null;
    }
  }

Create FedConfigurationsRepository

abstract class FedConfigurationsRepository {
  Future<FedConfigurations> getFedConfigurations(String userId);

  Future<void> saveFedConfigurations(
    String userId,
    FedConfigurations fedConfigurations,
  );

  Future<void> deleteFedConfigurations(String userId);
}

Create new Fed dio in NetworkDI

class NetworkDI extends BaseDI {
  static const fedServerUrlInterceptorName = 'fedServerDynamicUrlInterceptor';
  static const fedServerDioName = 'fedServerDioName';
  static const fedDioClientName = 'fedServerDioClientName';

  void _bindInterceptor(GetIt get) { 
    get.registerLazySingleton(
      () => DynamicUrlInterceptors(),
      instanceName: fedServerUrlInterceptorName,
    );
  }

  void _bindDio(GetIt get) {
    _bindDioForFedServer(get);
  }

  void _bindDioForFedServer(GetIt Get) {}
}

[nqhhdev]

How to work with Fed server

Create FedApi

class FedAPI {
 final DioClient _client = getIt.get<DioClient>(instanceName: NetworkDI.FedDioClientName);

 FedAPI();

  Future<FedHashDetailsResponse> getFedHashDetails() {}

  Future<FedLookupResponse> fedLookup() {}
}

[nqhhdev]

Request Fed token

• Use URL {{identityServer}}_matrix/client/v3/user/{{mxid}}/openid/request_token to call get Fed Token information

Response

{
    "access_token": "pXoIqYPEUwRUTMUAkjWMMIgF",
    "token_type": "Bearer",
    "matrix_server_name": "stg.lin-saas.com",
    "expires_in": 3600
}

Create FedTokenInformation

class FedTokenInformation  with EquatableMixin {
    @JsonKey(name: 'access_token')
    final String? fedAccessToken;
    @JsonKey(name: 'token_type')
    final String? fedTokenType;
    @JsonKey(name: 'matrix_server_name')
    final String? matrixServerName;
    @JsonKey(name: 'expires_in')
    final int? fedTokenExpiresIn;

    FedTokenInformation({
        this.fedAccessToken,
        this.fedTokenType,
        this.matrixServerName,
        this.fedTokenExpiresIn,
    });

}

Create FedAuthorizationInterceptor to handle accessToken after call request Fed token

class FedAuthorizationInterceptor extends InterceptorsWrapper {
  FedAuthorizationInterceptor();

  String? _accessToken;

  set accessToken(String? accessToken) {
    _accessToken = accessToken;
  }

  @override
  void onRequest(RequestOptions options, RequestInterceptorHandler handler) {
    options.headers[HttpHeaders.authorizationHeader] = _bearerToken;
    Logs().d('FedAuthorizationInterceptor::onRequest:accessToken: $_bearerToken');
    super.onRequest(options, handler);
  }

  String get _bearerToken => 'Bearer $_accessToken';
}

Handle accessToken is expired

• Create RefreshFedTokenInterceptor to handle this

class RefreshTokenInterceptor extends QueuedInterceptorsWrapper {
  final Dio dio;

  RefreshTokenInterceptor({required this.dio});

  @override
  Future onError(DioException err, ErrorInterceptorHandler handler) async {
    if (err.response == null) return handler.next(err);
    if (err.response!.statusCode == HttpStatus.forbidden) {
      try {
        final fedTokenInformation = await refreshToken();
        if (fedTokenInformation != null) {
          return await handleRefreshToken(
            err: err,
            handler: handler,
            fedTokenInformation: fedTokenInformation,
          );
        } else {
          await unAuthorize(err.response!);
        }
      } on DioException catch (refreshTokenError) {
        if (refreshTokenError.response!.statusCode == HttpStatus.forbidden) {
          await unAuthorize(refreshTokenError.response!);
          return handler.next(refreshTokenError);
        }
        return handler.next(refreshTokenError);
      } catch (error) {
        return handler.next(err);
      }
    }
    return handler.next(err);
  }

  /// Api to get new token from refresh token
  ///
  Future<FedTokenInformation?> refreshToken() async {
    try {
      ///
      return response;
    } catch (_) {
      rethrow;
    }
  }

  /// For retrying request with new token
  ///
  Future<void> handleRefreshToken({
    required FedTokenInformation fedTokenInformation,
    required DioException err,
    required ErrorInterceptorHandler handler,
  }) async {
    final Dio retryDio = Dio();
    final RequestOptions requestOptions = err.requestOptions;
    requestOptions.headers = {
      HttpHeaders.authorizationHeader: 'Bearer ${fedTokenInformation. fedAccessToken}',
    };
    await retryDio.fetch(requestOptions).then(
      handler.resolve,
      onError: (error) async {
        handler.reject(error);
      },
    );
  }

  Future<void> unAuthorize(Response response) async {
    if (response.statusCode == HttpStatus.forbidden) {}
  }
}

[nqhhdev]

How to get /hash_details in Fed?

Desc

• Create FedHashDetailsResponse

@JsonSerializable()
class FedHashDetailsResponse extends Equatable {
  @JsonKey(name: 'algorithms')
  final Set<String>? algorithms;

  @JsonKey(name: 'lookup_pepper')
  final String? lookupPepper;

  @JsonKey(name: 'alt_lookup_peppers')
  final Set<String>? altLookupPeppers;

  const FedHashDetailsResponse({
    this.algorithms,
    this.lookupPepper,
  });

  @override
  List<Object?> get props => [algorithms, lookupPepper];

  factory FedHashDetailsResponse.fromJson(Map<String, dynamic> json) =>
      _$FedHashDetailsResponseFromJson(json);

  Map<String, dynamic> toJson() => _$FedHashDetailsResponseToJson(this);
}

• Create getFedHashDetails method in FedAPI layer
• Update it on LookupDatasourceImpl: If support Fed Service → call getFedHashDetails else keep old logic

DoD

• Biding data if support Fed Server
• Get Fed hash details

[nqhhdev]

How to fetch /look_up in Fed?

Desc:

• Reuse LookupListMxidRequest for call fedLookup in FedAPI
• Create fedLookupListMxid method in FedAPI layer
• Update LookupListMxidResponse to reuse with Fed server and ToM server

@JsonSerializable()
class LookupListMxidResponse extends Equatable {
  @JsonKey(name: 'mappings')
  final Map<String, String>? mappings;

  @JsonKey(name: 'inactive_mappings')
  final Map<String, String>? inactiveMappings;

  @JsonKey(name: 'third_party_mappings')
  final Map<String, ThirdPartyMappingsData>? thirdPartyMappings;

  const LookupListMxidResponse({
    this.mappings,
    this.inactiveMappings,
    this.thirdPartyMappings,
  });

  factory LookupListMxidResponse.fromJson(Map<String, dynamic> json) =>
      _$LookupListMxidResponseFromJson(json);

  Map<String, dynamic> toJson() => _$LookupListMxidResponseToJson(this);

  @override
  List<Object?> get props => [mappings, inactiveMappings];
}

@JsonSerializable()
class ThirdPartyMappingsData with EquatableMixin {
  @JsonKey(name: 'actives')
  final Set<String>? actives;
  @JsonKey(name: 'inactives')
  final Set<String>? inactives;

  ThirdPartyMappingsData({
    this.actives,
    this.inactives,
  });

  factory ThirdPartyMappingsData.fromJson(Map<String, dynamic> json) =>
      _$ThirdPartyMappingsDataFromJson(json);
  
  Map<String, dynamic> toJson() => _$ThirdPartyMappingsDataToJson(this);
  
  @override
  List<Object?> get props => [actives, inactives];
}

[nqhhdev]

Update fetch Phonebook

Decs:

• Update Contact model:
  • Change phoneNumber => phoneNumbers
  • Change email => emails
  • Check duplicate phone or mail