EpochServiceImpl.java

package org.cardanofoundation.explorer.api.service.impl;

import java.math.BigInteger;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.temporal.ChronoUnit;
import java.util.*;

import lombok.RequiredArgsConstructor;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import org.cardanofoundation.explorer.api.common.enumeration.EpochStatus;
import org.cardanofoundation.explorer.api.exception.BusinessCode;
import org.cardanofoundation.explorer.api.exception.NoContentException;
import org.cardanofoundation.explorer.api.mapper.EpochMapper;
import org.cardanofoundation.explorer.api.model.response.BaseFilterResponse;
import org.cardanofoundation.explorer.api.model.response.EpochResponse;
import org.cardanofoundation.explorer.api.model.response.dashboard.EpochSummary;
import org.cardanofoundation.explorer.api.repository.ledgersync.AdaPotsRepository;
import org.cardanofoundation.explorer.api.repository.ledgersync.BlockRepository;
import org.cardanofoundation.explorer.api.repository.ledgersync.EpochRepository;
import org.cardanofoundation.explorer.api.service.EpochService;
import org.cardanofoundation.explorer.api.service.FetchRewardDataService;
import org.cardanofoundation.explorer.api.util.StreamUtil;
import org.cardanofoundation.explorer.common.entity.ledgersync.Block;
import org.cardanofoundation.explorer.common.entity.ledgersync.Epoch;
import org.cardanofoundation.explorer.common.exception.BusinessException;

@Service
@RequiredArgsConstructor
public class EpochServiceImpl implements EpochService {

  private final EpochRepository epochRepository;
  private final BlockRepository blockRepository;
  private final EpochMapper epochMapper;
  private final RedisTemplate<String, Object> redisTemplate;
  private final FetchRewardDataService fetchRewardDataService;
  private final AdaPotsRepository adaPotsRepository;
  private static final String UNIQUE_ACCOUNTS_KEY = "UNIQUE_ACCOUNTS";
  private static final String UNDERSCORE = "_";

  @Value("${application.network}")
  private String network;

  @Value("${application.epoch.days}")
  public int epochDays;

  @Value("${application.healthcheck.block-time-threshold}")
  private Long blockTimeThresholdInSecond;

  @Override
  public EpochResponse getEpochDetail(String no) {
    try {
      Integer epochNo = Integer.parseInt(no);
      Epoch epoch =
          epochRepository
              .findFirstByNo(epochNo)
              .orElseThrow(() -> new BusinessException(BusinessCode.EPOCH_NOT_FOUND));
      var currentEpoch =
          epochRepository
              .findCurrentEpochNo()
              .orElseThrow(() -> new BusinessException(BusinessCode.EPOCH_NOT_FOUND));
      if (Boolean.FALSE.equals(fetchRewardDataService.checkEpochRewardDistributed(epoch))
          && epoch.getNo() < currentEpoch - 1) {
        List<Epoch> fetchEpochResponse =
            fetchRewardDataService.fetchEpochRewardDistributed(List.of(epochNo));
        if (!CollectionUtils.isEmpty(fetchEpochResponse)) {
          epoch.setRewardsDistributed(fetchEpochResponse.get(0).getRewardsDistributed());
        }
      }
      Epoch firstEpoch =
          epochRepository
              .findFirstByNo(BigInteger.ZERO.intValue())
              .orElseThrow(() -> new BusinessException(BusinessCode.EPOCH_NOT_FOUND));

      Block currentBlock =
          blockRepository
              .findLatestBlock()
              .orElseThrow(() -> new BusinessException(BusinessCode.BLOCK_NOT_FOUND));

      LocalDateTime firstEpochStartTime = firstEpoch.getStartTime().toLocalDateTime();
      EpochResponse response = epochMapper.epochToEpochResponse(epoch);
      checkEpochStatus(response, currentBlock, currentEpoch);
      LocalDateTime startTime =
          modifyStartTimeAndEndTimeOfEpoch(firstEpochStartTime, response.getStartTime());
      response.setStartTime(startTime);
      response.setEndTime(startTime.plusDays(epochDays));
      String uniqueAccountRedisKey =
          String.join(UNDERSCORE, getRedisKey(UNIQUE_ACCOUNTS_KEY), epoch.getNo().toString());
      Integer account = redisTemplate.opsForHash().size(uniqueAccountRedisKey).intValue();
      response.setAccount(account);
      return response;
    } catch (NumberFormatException e) {
      throw new BusinessException(BusinessCode.EPOCH_NOT_FOUND);
    }
  }

  @Override
  public BaseFilterResponse<EpochResponse> getAllEpoch(Pageable pageable) {
    Block currentBlock =
        blockRepository
            .findLatestBlock()
            .orElseThrow(() -> new BusinessException(BusinessCode.BLOCK_NOT_FOUND));

    Epoch firstEpoch =
        epochRepository
            .findFirstByNo(BigInteger.ZERO.intValue())
            .orElseThrow(() -> new NoContentException(BusinessCode.EPOCH_NOT_FOUND));
    LocalDateTime firstEpochStartTime = firstEpoch.getStartTime().toLocalDateTime();

    var currentEpoch =
        epochRepository
            .findCurrentEpochNo()
            .orElseThrow(() -> new NoContentException(BusinessCode.EPOCH_NOT_FOUND));

    Page<Epoch> epochs = epochRepository.findAll(pageable);
    var epochNeedFetch =
        epochs.getContent().stream()
            .filter(
                epoch ->
                    !fetchRewardDataService.checkEpochRewardDistributed(epoch)
                        && epoch.getNo() < currentEpoch - 1)
            .map(Epoch::getNo)
            .toList();
    if (!CollectionUtils.isEmpty(epochNeedFetch)) {
      List<Epoch> fetchEpochList =
          fetchRewardDataService.fetchEpochRewardDistributed(epochNeedFetch);
      if (!CollectionUtils.isEmpty(fetchEpochList)) {
        Map<Integer, BigInteger> epochRewardMap =
            StreamUtil.toMap(fetchEpochList, Epoch::getNo, Epoch::getRewardsDistributed);
        epochs.forEach(
            epoch -> {
              if (epochRewardMap.containsKey(epoch.getNo())) {
                epoch.setRewardsDistributed(epochRewardMap.get(epoch.getNo()));
              }
            });
      }
    }

    Page<EpochResponse> pageResponse = epochs.map(epochMapper::epochToEpochResponse);
    pageResponse
        .getContent()
        .forEach(
            epoch -> {
              checkEpochStatus(epoch, currentBlock, currentEpoch);
              LocalDateTime startTime =
                  modifyStartTimeAndEndTimeOfEpoch(firstEpochStartTime, epoch.getStartTime());
              epoch.setStartTime(startTime);
              epoch.setEndTime(startTime.plusDays(epochDays));
              String uniqueAccountRedisKey =
                  String.join(
                      UNDERSCORE, getRedisKey(UNIQUE_ACCOUNTS_KEY), epoch.getNo().toString());
              epoch.setAccount(redisTemplate.opsForHash().size(uniqueAccountRedisKey).intValue());
            });
    return new BaseFilterResponse<>(pageResponse);
  }

  /**
   * Set time of epoch belongs to start time of first epoch Set hour, minute, second of epoch
   * belongs to hour, minute, second of first epoch
   *
   * @param firstEpochStartTime start time of first epoch
   * @param epochTime start time or end time of epoch
   * @return epoch time after modify
   */
  private LocalDateTime modifyStartTimeAndEndTimeOfEpoch(
      LocalDateTime firstEpochStartTime, LocalDateTime epochTime) {
    return LocalDateTime.of(
        epochTime.getYear(),
        epochTime.getMonth(),
        epochTime.getDayOfMonth(),
        firstEpochStartTime.getHour(),
        firstEpochStartTime.getMinute(),
        firstEpochStartTime.getSecond());
  }

  /**
   * Get epoch status from start time and end time
   *
   * <p>Start time < now < end time : in progress
   *
   * <p>End time > now - 10 day and not in progress: rewarding
   *
   * <p>Others: finished
   *
   * @param epoch epoch response
   */
  private void checkEpochStatus(EpochResponse epoch, Block currentBlock, int currentEpochNo) {
    epoch.setStatus(
        getEpochStatus(epoch.getStartTime(), epoch.getNo(), currentEpochNo, currentBlock));

    if (epoch.getStatus().equals(EpochStatus.FINISHED)) {
      epoch.setSyncingProgress(1D);
    } else {
      epoch.setSyncingProgress((double) currentBlock.getEpochSlotNo() / epoch.getMaxSlot());
    }
  }

  private EpochStatus getEpochStatus(
      LocalDateTime startTime, Integer epochNo, Integer currentEpochNo, Block currentBlock) {
    EpochStatus status;
    LocalDateTime currentTime = LocalDateTime.now(ZoneOffset.UTC);
    if (startTime.plusDays(epochDays).isAfter(currentTime) && startTime.isBefore(currentTime)) {
      status = EpochStatus.IN_PROGRESS;
    } else {
      status = EpochStatus.FINISHED;
    }

    if (epochNo.equals(currentEpochNo)
        && blockTimeThresholdInSecond
            <= ChronoUnit.SECONDS.between(currentBlock.getTime().toLocalDateTime(), currentTime)) {
      status = EpochStatus.SYNCING;
    }
    return status;
  }

  @Override
  public EpochSummary getCurrentEpochSummary() {
    Block currentBlock =
        blockRepository
            .findLatestBlock()
            .orElseThrow(() -> new BusinessException(BusinessCode.BLOCK_NOT_FOUND));

    return epochRepository
        .findCurrentEpochSummary()
        .map(
            epochSummaryProjection -> {
              var currentLocalDateTime = LocalDateTime.ofInstant(Instant.now(), ZoneOffset.UTC);
              var epochStartTime = epochSummaryProjection.getStartTime().toLocalDateTime();
              Epoch firstEpoch =
                  epochRepository
                      .findFirstByNo(BigInteger.ZERO.intValue())
                      .orElseThrow(() -> new NoContentException(BusinessCode.EPOCH_NOT_FOUND));
              LocalDateTime firstEpochStartTime = firstEpoch.getStartTime().toLocalDateTime();
              epochStartTime =
                  modifyStartTimeAndEndTimeOfEpoch(firstEpochStartTime, epochStartTime);
              var slot =
                  currentLocalDateTime.toEpochSecond(ZoneOffset.UTC)
                      - epochStartTime.toEpochSecond(ZoneOffset.UTC);
              String uniqueAccountRedisKey =
                  String.join(
                      UNDERSCORE,
                      getRedisKey(UNIQUE_ACCOUNTS_KEY),
                      epochSummaryProjection.getNo().toString());
              var account = redisTemplate.opsForHash().size(uniqueAccountRedisKey).intValue();
              if (Boolean.FALSE.equals(
                  fetchRewardDataService.checkAdaPots(epochSummaryProjection.getNo()))) {
                fetchRewardDataService.fetchAdaPots(List.of(epochSummaryProjection.getNo()));
              }
              return EpochSummary.builder()
                  .no(epochSummaryProjection.getNo())
                  .slot((int) slot)
                  .totalSlot(epochSummaryProjection.getMaxSlot())
                  .startTime(epochStartTime)
                  .endTime(epochStartTime.plusDays(epochDays))
                  .account(account)
                  .status(
                      getEpochStatus(
                          epochStartTime,
                          epochSummaryProjection.getNo(),
                          epochSummaryProjection.getNo(),
                          currentBlock))
                  .syncingProgress(
                      (double) currentBlock.getEpochSlotNo() / epochSummaryProjection.getMaxSlot())
                  .blkCount(epochSummaryProjection.getBlkCount())
                  .build();
            })
        .orElse(EpochSummary.builder().slot(0).no(0).totalSlot(0).build());
  }

  private String getRedisKey(String key) {
    return String.join(UNDERSCORE, network.toUpperCase(), key);
  }
}
















































Active mutators

CONDITIONALS_BOUNDARY
EMPTY_RETURNS
FALSE_RETURNS
INCREMENTS
INVERT_NEGS
MATH
NEGATE_CONDITIONALS
NULL_RETURNS
PRIMITIVE_RETURNS
TRUE_RETURNS
VOID_METHOD_CALLS

Tests examined

org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testGetEpochDetail_throwCurrentEpoch()] (2 ms)
org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testGetEpochDetailThrowCauseNotFound()] (2 ms)
org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testGetEpochDetail_thenReturnNotRewardDistributed()] (3 ms)
org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testGetEpochDetailReward()] (5 ms)
org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testGetAllEpoch_thenReturn()] (5 ms)
org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testGetCurrentEpochSummary_thenReturn()] (175 ms)
org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testGetEpochDetailSync()] (4 ms)
org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testGetEpochDetailDone()] (3 ms)
org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testCurrentEpochSummary()] (3 ms)
org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testGetAllEpoch_throwCurrentEpochNo()] (3 ms)
org.cardanofoundation.explorer.api.service.EpochServiceTest.[engine:junit-jupiter]/[class:org.cardanofoundation.explorer.api.service.EpochServiceTest]/[method:testGetEpochDetailInProgress()] (3 ms)

Report generated by PIT 1.14.2

1		package org.cardanofoundation.explorer.api.service.impl;
2
3		import java.math.BigInteger;
4		import java.time.Instant;
5		import java.time.LocalDateTime;
6		import java.time.ZoneOffset;
7		import java.time.temporal.ChronoUnit;
8		import java.util.*;
9
10		import lombok.RequiredArgsConstructor;
11
12		import org.springframework.beans.factory.annotation.Value;
13		import org.springframework.data.domain.Page;
14		import org.springframework.data.domain.Pageable;
15		import org.springframework.data.redis.core.RedisTemplate;
16		import org.springframework.stereotype.Service;
17		import org.springframework.util.CollectionUtils;
18
19		import org.cardanofoundation.explorer.api.common.enumeration.EpochStatus;
20		import org.cardanofoundation.explorer.api.exception.BusinessCode;
21		import org.cardanofoundation.explorer.api.exception.NoContentException;
22		import org.cardanofoundation.explorer.api.mapper.EpochMapper;
23		import org.cardanofoundation.explorer.api.model.response.BaseFilterResponse;
24		import org.cardanofoundation.explorer.api.model.response.EpochResponse;
25		import org.cardanofoundation.explorer.api.model.response.dashboard.EpochSummary;
26		import org.cardanofoundation.explorer.api.repository.ledgersync.AdaPotsRepository;
27		import org.cardanofoundation.explorer.api.repository.ledgersync.BlockRepository;
28		import org.cardanofoundation.explorer.api.repository.ledgersync.EpochRepository;
29		import org.cardanofoundation.explorer.api.service.EpochService;
30		import org.cardanofoundation.explorer.api.service.FetchRewardDataService;
31		import org.cardanofoundation.explorer.api.util.StreamUtil;
32		import org.cardanofoundation.explorer.common.entity.ledgersync.Block;
33		import org.cardanofoundation.explorer.common.entity.ledgersync.Epoch;
34		import org.cardanofoundation.explorer.common.exception.BusinessException;
35
36		@Service
37		@RequiredArgsConstructor
38		public class EpochServiceImpl implements EpochService {
39
40		private final EpochRepository epochRepository;

EpochServiceImpl.java

Mutations

Active mutators

Tests examined