com.arextest.storage.service.MockSourceEditionService Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of arex-storage-web-api Show documentation
There is a newer version: 2.0.7
package com.arextest.storage.service;

import com.arextest.model.mock.AREXMocker;
import com.arextest.model.mock.MergeRecordDTO;
import com.arextest.model.mock.MockCategoryType;
import com.arextest.model.mock.Mocker;
import com.arextest.storage.repository.RepositoryProvider;
import com.arextest.storage.repository.RepositoryProviderFactory;
import com.arextest.storage.utils.JsonUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import java.util.Date;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class MockSourceEditionService {

  private final RepositoryProviderFactory providerFactory;
  private final ScheduleReplayingService scheduleReplayingService;
  private static final String LOG_TITLE_OPERATE_MOCKER = "[[title=operateMocker]]";

  public MockSourceEditionService(RepositoryProviderFactory providerFactory,
      ScheduleReplayingService scheduleReplayingService,
      Set entryPointTypes) {
    this.providerFactory = providerFactory;
    this.scheduleReplayingService = scheduleReplayingService;
  }

  public  boolean add(String providerName, T item) {
    RepositoryProvider repositoryWriter = providerFactory.findProvider(providerName);
    return repositoryWriter != null && repositoryWriter.save(item);
  }

  public  T editMergedMocker(String providerName, AREXMocker item) {
    RepositoryProvider repositoryProvider = providerFactory.findProvider(providerName);
    if (repositoryProvider == null) {
      LOGGER.warn("Could not found provider for {}", providerName);
      return null;
    }
    if (item.getId() == null) {
      LOGGER.warn("The id is empty");
      return null;
    }
    T mergedMocker = repositoryProvider.queryById(item.getCategoryType(), item.getId());
    mergedMocker.setCategoryType(item.getCategoryType());
    try {
      List mergeRecordDTOS = new ArrayList<>(
          JsonUtil.OBJECT_MAPPER.readValue(mergedMocker.getTargetResponse().getBody(),
              new TypeReference>() {
              }));
      MergeRecordDTO mergeRecordDTO = mergeRecordDTOS.get(item.getIndex());
      mergeRecordDTO.setRequest(item.getTargetRequest().getBody());
      mergeRecordDTO.setResponse(item.getTargetResponse().getBody());
      mergeRecordDTO.setUseMock(item.getUseMock());
      mergedMocker.getTargetResponse()
          .setBody(JsonUtil.OBJECT_MAPPER.writeValueAsString(mergeRecordDTOS));
    } catch (Exception e) {
      LOGGER.error("parse merge record error:{}", e.getMessage(), e);
    }
    return mergedMocker;
  }

  public  boolean update(String providerName, T item) {
    RepositoryProvider repositoryWriter = providerFactory.findProvider(providerName);
    item.setUpdateTime(System.currentTimeMillis());
    return repositoryWriter != null && repositoryWriter.update(item);
  }

  public boolean removeAll(String providerName, String recordId) {
    if (StringUtils.isBlank(recordId)) {
      LOGGER.warn("The recordId is empty");
      return false;
    }
    RepositoryProvider repositoryWriter = providerFactory.findProvider(providerName);
    if (repositoryWriter == null) {
      LOGGER.warn("Could not found provider for {}", providerName);
      return false;
    }
    Set categoryTypes = providerFactory.getCategoryTypes();
    Map removeResults = new HashMap<>(categoryTypes.size());
    for (MockCategoryType categoryType : categoryTypes) {
      long removeResult = repositoryWriter.removeBy(categoryType, recordId);
      removeResults.put(categoryType.getName(), removeResult > 0);
    }
    LOGGER.info("remove all record result:{} for recordId:{}", removeResults, recordId);
    return true;
  }

  public boolean removeAllByAppId(String providerName, String appId) {
    if (StringUtils.isBlank(appId)) {
      LOGGER.warn("The appId is empty");
      return false;
    }
    RepositoryProvider repositoryWriter = providerFactory.findProvider(providerName);
    if (repositoryWriter == null) {
      LOGGER.warn("Could not found provider for {}", providerName);
      return false;
    }
    Set categoryTypes = providerFactory.getCategoryTypes();
    for (MockCategoryType categoryType : categoryTypes) {
      repositoryWriter.removeByAppId(categoryType, appId);
    }
    return true;
  }

  public boolean removeAllByOperationNameAndAppId(String providerName, String operationName,
      String appId) {
    RepositoryProvider repositoryWriter = providerFactory.findProvider(providerName);
    if (StringUtils.isBlank(appId)) {
      LOGGER.warn("The appId is empty");
      return false;
    }
    if (repositoryWriter == null) {
      LOGGER.warn("Could not found provider for {}", providerName);
      return false;
    }
    Set categoryTypes = providerFactory.getCategoryTypes();
    for (MockCategoryType categoryType : categoryTypes) {
      repositoryWriter.removeByOperationNameAndAppId(categoryType, operationName, appId);
    }
    return true;
  }

  public boolean remove(String providerName, String categoryName, String recordId, String id) {
    try {
      RepositoryProvider repositoryWriter = providerFactory.findProvider(providerName);
      if (repositoryWriter == null) {
        LOGGER.warn("Could not found provider for {}", providerName);
        return false;
      }
      MockCategoryType categoryType = providerFactory.findCategory(categoryName);
      if (categoryType == null) {
        LOGGER.warn(
            "Could not found category for {}, did you customize a new category? try register it" +
                " in " +
                "config file",
            categoryName);
        return false;
      }
      if (StringUtils.isEmpty(id)) {
        return repositoryWriter.removeBy(categoryType, recordId) > 0;
      }
      return repositoryWriter.removeById(categoryType, id) > 0;
    } catch (Throwable throwable) {
      LOGGER.error("remove record error:{} from {} for category:{} at recordId:{} id:{}",
          throwable.getMessage(),
          providerName, categoryName,
          recordId,
          id,
          throwable);
      return false;
    }
  }

  public int copyTo(String srcProviderName, String srcRecordId, String targetProviderName,
      String targetRecordId) {
    int count = 0;
    if (StringUtils.equals(srcProviderName, targetProviderName) && StringUtils.equals(srcRecordId, targetRecordId)) {
      return count;
    }
    RepositoryProvider srcProvider = providerFactory.findProvider(srcProviderName);
    RepositoryProvider targetProvider = providerFactory.findProvider(targetProviderName);
    if (srcProvider == null || targetProvider == null) {
      LOGGER.warn("could not found provider for {} or {}", srcProvider, targetProvider);
      return count;
    }
    List srcMockers;
    Set categoryTypes = providerFactory.getCategoryTypes();
    for (MockCategoryType categoryType : categoryTypes) {
      srcMockers = scheduleReplayingService.queryRecordList(srcProvider, categoryType, srcRecordId);
      if (CollectionUtils.isEmpty(srcMockers)) {
        continue;
      }
      List targetList = createTargetList(srcMockers, targetRecordId);
      if (CollectionUtils.isNotEmpty(targetList)) {
        if (targetProvider.saveList(targetList)) {
          count += targetList.size();
        }
      }
    }
    return count;
  }

  public int moveTo(String srcProviderName, String srcRecordId, String targetProviderName) {
    int movedCount = copyTo(srcProviderName, srcRecordId, targetProviderName, srcRecordId);
    LOGGER.info("{}copy recordId {}, from {} to {}, movedCount: {}",
        LOG_TITLE_OPERATE_MOCKER, srcRecordId, srcProviderName, targetProviderName, movedCount);
    if (movedCount != 0) {
      removeByRecordId(srcProviderName, srcRecordId);
    }
    return movedCount;
  }

  public boolean removeByRecordId(String providerName, String recordId) {
    RepositoryProvider repositoryWriter = providerFactory.findProvider(providerName);
    if (repositoryWriter == null) {
      LOGGER.warn("{}Could not found provider for {}", LOG_TITLE_OPERATE_MOCKER, providerName);
      return false;
    }
    long deleteCount = 0;
    for (MockCategoryType categoryType : providerFactory.getCategoryTypes()) {
      deleteCount += repositoryWriter.removeBy(categoryType, recordId);
    }
    LOGGER.info("{}removeByRecordId deleted {} {} mockers for recordId: {}",
        LOG_TITLE_OPERATE_MOCKER, deleteCount, providerName, recordId);
    return deleteCount > 0L;
  }

  public boolean extendMockerExpirationByRecordId(String providerName, String recordId, Long extensionDays) {
    RepositoryProvider repositoryWriter = providerFactory.findProvider(providerName);
    if (repositoryWriter == null) {
      LOGGER.warn("Could not found provider for {}", providerName);
      return false;
    }
    long updateCount = 0;
    Date expireDate = Date.from(LocalDateTime.now().plusDays(extensionDays).atZone(
        ZoneId.systemDefault()).toInstant());

    for (MockCategoryType categoryType : providerFactory.getCategoryTypes()) {
      updateCount += repositoryWriter.extendExpirationTo(categoryType, recordId,
          expireDate);
    }
    LOGGER.info("extendMockerExpirationByRecordId updated {} mockers for recordId: {}",
        updateCount, recordId);
    return updateCount > 0;
  }

  private List createTargetList(List srcMockers, String targetRecordId) {
    List targetList = null;
    for (Mocker mocker: srcMockers) {
      if (targetList == null) {
        targetList = new LinkedList<>();
      }
      mocker.setRecordId(targetRecordId);
      mocker.setId(null);
      mocker.setUpdateTime(System.currentTimeMillis());
      targetList.add(mocker);
    }
    return targetList;
  }
}