getValidationSessionFlipsList method

Future<ValidationSessionInfo> getValidationSessionFlipsList(String typeSession, ValidationSessionInfo validationSessionInfoInput, bool simulationMode, String address,)

Implementation

Future<ValidationSessionInfo> getValidationSessionFlipsList(
    String typeSession,
    ValidationSessionInfo validationSessionInfoInput,
    bool simulationMode,
    String address) async {
  Completer<ValidationSessionInfo> _completer =
      new Completer<ValidationSessionInfo>();

  if (validationSessionInfoInput != null) {
    _completer.complete(validationSessionInfoInput);
    return _completer.future;
  }

  ValidationSessionInfo validationSessionInfo = new ValidationSessionInfo();
  validationSessionInfo.typeSession = typeSession;
  String method;

  switch (typeSession) {
    case EpochPeriod.ShortSession:
      {
        method = FlipShortHashesRequest.METHOD_NAME;
      }
      break;
    case EpochPeriod.LongSession:
      {
        method = FlipLongHashesRequest.METHOD_NAME;
      }
      break;
    default:
      return validationSessionInfo;
  }

  FlipShortHashesRequest flipShortHashesRequest;
  FlipShortHashesResponse flipShortHashesResponse;
  FlipLongHashesRequest flipLongHashesRequest;
  FlipLongHashesResponse flipLongHashesResponse;

  try {
    if (simulationMode) {
      if (typeSession == EpochPeriod.ShortSession) {
        flipShortHashesResponse = FlipShortHashesResponse.fromJson(
            FlipExamples().getMapExample(typeSession));
      }
      if (typeSession == EpochPeriod.LongSession) {
        flipLongHashesResponse = FlipLongHashesResponse.fromJson(
            FlipExamples().getMapExample(typeSession));
      }
    } else {
      if (this.nodeType == SHARED_NODE) {
        mapParams = {
          'method': method,
          "params": [address],
          'id': 101,
          'key': keyApp
        };
      } else {
        mapParams = {
          'method': method,
          "params": [],
          'id': 101,
          'key': keyApp
        };
      }

      if (typeSession == EpochPeriod.ShortSession) {
        if (this.nodeType == NORMAL_VPS_NODE) {
          SSHClientStatus sshClientStatus;
          sshClientStatus = await VpsUtil().connectVps(apiUrl, keyApp);
          if (sshClientStatus.sshClientStatus) {
            sshClient = sshClientStatus.sshClient;
          }
          var response = await ssh.HttpClientImpl(
                  clientFactory: () =>
                      ssh.SSHTunneledBaseClient(sshClientStatus.sshClient))
              .request(apiUrl,
                  method: 'POST',
                  data: jsonEncode(mapParams),
                  headers: requestHeaders);
          if (response.status == 200) {
            flipShortHashesResponse =
                flipShortHashesResponseFromJson(response.text);
          }
        } else {
          flipShortHashesRequest = FlipShortHashesRequest.fromJson(mapParams);
          logger.i(new JsonEncoder.withIndent('  ')
              .convert(flipShortHashesRequest));
          body = json.encode(flipShortHashesRequest.toJson());
          responseHttp = await http.post(Uri.parse(this.apiUrl),
              body: body, headers: requestHeaders);
          if (responseHttp.statusCode == 200) {
            flipShortHashesResponse =
                flipShortHashesResponseFromJson(responseHttp.body);
          }
        }
      }
      if (typeSession == EpochPeriod.LongSession) {
        if (this.nodeType == NORMAL_VPS_NODE) {
          SSHClientStatus sshClientStatus;
          sshClientStatus = await VpsUtil().connectVps(apiUrl, keyApp);
          if (sshClientStatus.sshClientStatus) {
            sshClient = sshClientStatus.sshClient;
          }
          var response = await ssh.HttpClientImpl(
                  clientFactory: () =>
                      ssh.SSHTunneledBaseClient(sshClientStatus.sshClient))
              .request(apiUrl,
                  method: 'POST',
                  data: jsonEncode(mapParams),
                  headers: requestHeaders);
          if (response.status == 200) {
            flipLongHashesResponse =
                flipLongHashesResponseFromJson(response.text);
          }
        } else {
          flipLongHashesRequest = FlipLongHashesRequest.fromJson(mapParams);
          logger.i(new JsonEncoder.withIndent('  ')
              .convert(flipLongHashesRequest));
          body = json.encode(flipLongHashesRequest.toJson());
          responseHttp = await http.post(Uri.parse(this.apiUrl),
              body: body, headers: requestHeaders);
          if (responseHttp.statusCode == 200) {
            flipLongHashesResponse =
                flipLongHashesResponseFromJson(responseHttp.body);
          }
        }
      }
    }

    List<ValidationSessionInfoFlips> listSessionValidationFlip =
        List<ValidationSessionInfoFlips>.empty(growable: true);
    List<ValidationSessionInfoFlips> listSessionValidationFlipExtra =
        List<ValidationSessionInfoFlips>.empty(growable: true);
    int nbFlips = 0;
    if (typeSession == EpochPeriod.ShortSession) {
      nbFlips = flipShortHashesResponse.result.length;
    }
    if (typeSession == EpochPeriod.LongSession) {
      nbFlips = flipLongHashesResponse.result.length;
    }

    for (int i = 0; i < nbFlips; i++) {
      ValidationSessionInfoFlips validationSessionInfoFlips =
          new ValidationSessionInfoFlips();
      if (typeSession == EpochPeriod.ShortSession) {
        validationSessionInfoFlips.hash =
            flipShortHashesResponse.result[i].hash;
        validationSessionInfoFlips.ready =
            flipShortHashesResponse.result[i].ready;
        validationSessionInfoFlips.extra =
            flipShortHashesResponse.result[i].extra;
        validationSessionInfoFlips.available =
            flipShortHashesResponse.result[i].available;
        validationSessionInfoFlips.answerType = AnswerType.NONE;
        validationSessionInfoFlips.relevanceType = RelevantType.NO_INFO;
      }
      if (typeSession == EpochPeriod.LongSession) {
        validationSessionInfoFlips.hash =
            flipLongHashesResponse.result[i].hash;
        validationSessionInfoFlips.ready =
            flipLongHashesResponse.result[i].ready;
        validationSessionInfoFlips.extra =
            flipLongHashesResponse.result[i].extra;
        validationSessionInfoFlips.available =
            flipLongHashesResponse.result[i].available;
        validationSessionInfoFlips.answerType = AnswerType.NONE;
        validationSessionInfoFlips.relevanceType = RelevantType.NO_INFO;
      }

      if (validationSessionInfoFlips.extra) {
        listSessionValidationFlipExtra.add(validationSessionInfoFlips);
      } else {
        if (this.nodeType == SHARED_NODE) {
          listSessionValidationFlip.add(validationSessionInfoFlips);
        } else {
          if (validationSessionInfoFlips.ready) {
            listSessionValidationFlip.add(validationSessionInfoFlips);
          }
        }
      }
    }

    validationSessionInfo.listSessionValidationFlips =
        listSessionValidationFlip;
    validationSessionInfo.listSessionValidationFlipsExtra =
        listSessionValidationFlipExtra;
  } catch (e) {
    logger.e(e.toString());
  }
  _completer.complete(validationSessionInfo);

  return _completer.future;
}