📚 atdd-subway-fare 미션 정리

@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
    String credentials = AuthorizationExtractor.extract(webRequest.getNativeRequest(HttpServletRequest.class));
    LoginMember member = authService.findMemberByToken(credentials);
    if (member.getId() == null) {
        throw new AuthorizationException();
    }
    return member;
}

private void unAuthorizedThrowException(@AuthenticationPrincipal LoginMember loginMember) {
    if (loginMember.getId() == null) {
        throw new AuthorizationException();
    }
}

private LoginMember unLoginMemberWrapper(@AuthenticationPrincipal LoginMember loginMember) {
  if (loginMember.getId() == null) {
    return new LoginMember(null, null, -1);
  }
  return loginMember;
}

public class AgeAuthenticationPrincipalArgumentResolver implements HandlerMethodArgumentResolver {
    private AuthService authService;

    public AgeAuthenticationPrincipalArgumentResolver(AuthService authService) {
        this.authService = authService;
    }

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(AgeAuthenticationPrincipal.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
        String credentials = AuthorizationExtractor.extract(Objects.requireNonNull(webRequest.getNativeRequest(HttpServletRequest.class)));
        LoginMember memberByToken = authService.findMemberByToken(credentials);
        return memberByToken.getAge();
    }
}

public PathResponse findPath(Integer age, Long source, Long target) {
    try {
        List<Line> lines = lineService.findLines();
        Station sourceStation = stationService.findStationById(source);
        Station targetStation = stationService.findStationById(target);
        SubwayPath subwayPath = pathFinder.findPath(lines, sourceStation, targetStation);
        int distance = subwayPath.calculateDistance();
        int lineFare = subwayPath.getMaxLineFare();
        SubwayPathFare subwayPathFare = new SubwayPathFare(age, distance, lineFare);
        return PathResponseAssembler.assemble(subwayPath, subwayPathFare);
    } catch (Exception e) {
        throw new InvalidPathException();
    }
}

public class SubwayPathFare {
    private final Integer age;
    private final int distance;
    private final int lineFare;

    public SubwayPathFare(Integer age, int distance, int lineFare) {
        this.age = wrapAge(age);
        this.distance = distance;
        this.lineFare = lineFare;
    }

    private int wrapAge(Integer age) {
        if (age == null) {
            return -1;
        }
        return age;
    }

    public int getFare() {
        int fareByDistance = FareCalculatorByDistance.from(distance);
        return FareAdjusterByAge.of(age, fareByDistance, lineFare);
    }
}

public static int of(int age, int fare, int lineFare) {
    return Arrays.stream(values())
            .filter(ageRange -> ageRange.minInclusive <= age && age < ageRange.maxExclusive)
            .map(calculator -> calculator.adjuster.apply(fare, lineFare))
            .findAny()
            .orElse(fare + lineFare);
}

public enum FareCalculatorByDistance {
    BASE(0, Constants.BASE_MAX_BOUNDARY, distance -> Constants.BASE_FARE),
    FIRST_ADDITIONAL(Constants.BASE_MAX_BOUNDARY, Constants.FIRST_ADDITIONAL_MAX_BOUNDARY,
            (distance) -> Constants.BASE_FARE + (int) ((Math.ceil((distance - Constants.BASE_MAX_BOUNDARY - 1) / 5)) + 1) * Constants.EXTRA_FARE),
    SECOND_ADDITIONAL(Constants.FIRST_ADDITIONAL_MAX_BOUNDARY, Integer.MAX_VALUE,
            (distance) -> Constants.BASE_FARE + 800 + (int) ((Math.ceil((distance - Constants.FIRST_ADDITIONAL_MAX_BOUNDARY - 1) / 8)) + 1) * Constants.EXTRA_FARE);


    private final int minExclusive;
    private final int maxInclusive;
    private final UnaryOperator<Integer> calculator;

    FareCalculatorByDistance(int minExclusive, int maxInclusive, UnaryOperator<Integer> calculator) {
        this.minExclusive = minExclusive;
        this.maxInclusive = maxInclusive;
        this.calculator = calculator;
    }

public enum FareAdjusterByAge {
    PRE_SCHOOLED(0, Constants.PRE_SCHOOL_MAX_BOUNDARY, getIntegerBinaryOperator(0)),
    SCHOOL_AGED(Constants.PRE_SCHOOL_MAX_BOUNDARY, Constants.SCHOOL_AGED_MAX_BOUNDARY, getIntegerBinaryOperator(Constants.SCHOOL_AGED_RATE)),
    ADOLESCENT(Constants.SCHOOL_AGED_MAX_BOUNDARY, Constants.ADOLESCENT_MAX_BOUNDARY, getIntegerBinaryOperator(Constants.ADOLESCENT_RATE));

    private final int minInclusive;
    private final int maxExclusive;
    private final BinaryOperator<Integer> adjuster;

    FareAdjusterByAge(int minInclusive, int maxExclusive, BinaryOperator<Integer> adjuster) {
        this.minInclusive = minInclusive;
        this.maxExclusive = maxExclusive;
        this.adjuster = adjuster;
    }

    private static BinaryOperator<Integer> getIntegerBinaryOperator(double rate) {
        return (fare, lineFare) -> (int) (((fare + lineFare) - 350) * rate);
    }

@ActiveProfiles("test")
@AutoConfigureRestDocs
public class ControllerTest {
    @Autowired
    public MockMvc mockMvc;

    @Autowired
    public ObjectMapper objectMapper;

    protected static OperationRequestPreprocessor getDocumentRequest() {
        return preprocessRequest(
                modifyUris()
                        .scheme("https")
                        .host("newwisdom-subway.p-e.kr")
                        .removePort(),
                prettyPrint());
    }

    protected static OperationResponsePreprocessor getDocumentResponse() {
        return preprocessResponse(prettyPrint());
    }
}

@ExceptionHandler(BusinessException.class)
public ResponseEntity<ErrorMessage> handleRuntimeException(BusinessException e) {

  return ResponseEntity.status(e.getHttpStatus()).body(e.getErrorMessage());
}

public class BusinessException extends RuntimeException {
    private final HttpStatus httpStatus;
    private final ErrorMessage errorMessage;

    public BusinessException(HttpStatus httpStatus, String errorMessage) {
        this(httpStatus, new ErrorMessage(errorMessage));
    }

    public BusinessException(HttpStatus httpStatus, ErrorMessage errorMessage) {
        this.httpStatus = httpStatus;
        this.errorMessage = errorMessage;
    }

    public HttpStatus getHttpStatus() {
        return httpStatus;
    }

    public ErrorMessage getErrorMessage() {
        return errorMessage;
    }
}

public class AuthorizationException extends BusinessException {
    public AuthorizationException(String message) {
        super(HttpStatus.UNAUTHORIZED, message);
    }
}

public class BadRequestException extends BusinessException {
    public BadRequestException(String message) {
        super(HttpStatus.BAD_REQUEST, message);
    }
}