Function bodies 391 total

public record ModelRelationRequest(
  @NotNull UUID targetModelId,
  @NotNull ModelRelation.Type type,
  String note
) {
}

public class GlobalExceptionHandler {

  @ExceptionHandler(EntityNotFoundException.class)
  public ProblemDetail handleNotFound(EntityNotFoundException ex) {
    return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
  }

  @ExceptionHandler(IllegalStateException.class)
  public ProblemDetail handleConflict(IllegalStateException ex) {
    return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, ex.getMessage());
  }

  @ExceptionHandler(DataIntegrityViolationException.class)
  public ProblemDetail handleDataIntegrity(DataIntegrityViolationException ex) {
    return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT,
      "Data integrity violation: a uniqueness or referential constraint was broken");
  }

  @ExceptionHandler(IllegalArgumentException.class)
  public ProblemDetail handleBadRequest(IllegalArgumentException ex) {
    return ProblemDetail.forStatusAndDetail(HttpStatus.BAD_REQUEST, ex.getMessage());
  }

  @ExceptionHandler(MethodArgumentNotVal

  public ProblemDetail handleNotFound(EntityNotFoundException ex) {
    return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
  }

  public ProblemDetail handleConflict(IllegalStateException ex) {
    return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, ex.getMessage());
  }

  public ProblemDetail handleDataIntegrity(DataIntegrityViolationException ex) {
    return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT,
      "Data integrity violation: a uniqueness or referential constraint was broken");
  }

  public ProblemDetail handleBadRequest(IllegalArgumentException ex) {
    return ProblemDetail.forStatusAndDetail(HttpStatus.BAD_REQUEST, ex.getMessage());
  }

  public ProblemDetail handleValidation(MethodArgumentNotValidException ex) {
    var detail = ProblemDetail.forStatusAndDetail(HttpStatus.BAD_REQUEST, "Validation failed");
    detail.setProperty("errors", ex.getBindingResult().getFieldErrors().stream()
      .map(e -> e.getField() + ": " + e.getDefaultMessage())
      .toList()
    );
    return detail;
  }

public class TransmissionController {

  private final TransmissionService transmissionService;

  public TransmissionController(TransmissionService transmissionService) {
    this.transmissionService = transmissionService;
  }

  @GetMapping
  @Operation(summary = "Get all transmissions")
  public List<TransmissionResponse> getAll(@RequestParam(required = false) TransmissionType type) {
    var list = type != null
      ? transmissionService.getByType(type)
      : transmissionService.getAll();
    return list.stream().map(TransmissionResponse::from).toList();
  }

  @GetMapping("/{id}")
  @Operation(summary = "Get transmission by ID")
  public TransmissionResponse getById(@PathVariable UUID id) {
    return TransmissionResponse.from(transmissionService.getById(new TransmissionId(id)));
  }

  @PostMapping
  @Operation(summary = "Create a new transmission")
  public ResponseEntity<TransmissionResponse> create(@Valid @RequestBody TransmissionRequest request) {
    var transmission = tr

  public TransmissionController(TransmissionService transmissionService) {
    this.transmissionService = transmissionService;
  }

  public TransmissionResponse getById(@PathVariable UUID id) {
    return TransmissionResponse.from(transmissionService.getById(new TransmissionId(id)));
  }

  public ResponseEntity<TransmissionResponse> create(@Valid @RequestBody TransmissionRequest request) {
    var transmission = transmissionService.create(request.type(), request.gearCount());
    var uri = ServletUriComponentsBuilder.fromCurrentRequest()
      .path("/{id}").buildAndExpand(transmission.id().value()).toUri();
    return ResponseEntity.created(uri).body(TransmissionResponse.from(transmission));
  }

public record TransmissionRequest(
  @NotNull TransmissionType type,
  @Min(1) @Max(12) int gearCount
) {
}

public record TransmissionResponse(UUID id, String type, int gearCount) {

  public static TransmissionResponse from(Transmission t) {
    return new TransmissionResponse(t.id().value(), t.type().name(), t.gearCount());
  }
}

public record TransmissionResponse(UUID id, String type, int gearCount) {

  public static TransmissionResponse from(Transmission t) {
    return new TransmissionResponse(t.id().value(), t.type().name(), t.gearCount());
  }
}

  public static TransmissionResponse from(Transmission t) {
    return new TransmissionResponse(t.id().value(), t.type().name(), t.gearCount());
  }

public class VariantController {

  private final VariantService variantService;

  public VariantController(VariantService variantService) {
    this.variantService = variantService;
  }

  @GetMapping
  @Operation(summary = "Get variants by body")
  public List<VariantResponse> getByBody(@RequestParam UUID bodyId) {
    return variantService.getByBody(new BodyId(bodyId)).stream()
      .map(VariantResponse::from).toList();
  }

  @GetMapping("/{id}")
  @Operation(summary = "Get variant by ID")
  public VariantResponse getById(@PathVariable UUID id) {
    return VariantResponse.from(variantService.getById(new VariantId(id)));
  }

  @PostMapping
  @Operation(summary = "Create a new variant")
  public ResponseEntity<VariantResponse> create(@Valid @RequestBody VariantRequest request) {
    var variant = variantService.create(
      new BodyId(request.bodyId()),
      new TransmissionId(request.transmissionId()),
      request.drivetrain(),
      request.curbWeightKg(),
      request.gro

  public VariantController(VariantService variantService) {
    this.variantService = variantService;
  }

  public List<VariantResponse> getByBody(@RequestParam UUID bodyId) {
    return variantService.getByBody(new BodyId(bodyId)).stream()
      .map(VariantResponse::from).toList();
  }

  public VariantResponse getById(@PathVariable UUID id) {
    return VariantResponse.from(variantService.getById(new VariantId(id)));
  }

  public ResponseEntity<VariantResponse> create(@Valid @RequestBody VariantRequest request) {
    var variant = variantService.create(
      new BodyId(request.bodyId()),
      new TransmissionId(request.transmissionId()),
      request.drivetrain(),
      request.curbWeightKg(),
      request.groundClearanceMm(),
      request.systemPowerKw()
    );
    var uri = ServletUriComponentsBuilder.fromCurrentRequest()
      .path("/{id}").buildAndExpand(variant.id().value()).toUri();
    return ResponseEntity.created(uri).body(VariantResponse.from(variant));
  }

  public VariantResponse addEngine(@PathVariable UUID id, @PathVariable UUID engineId) {
    return VariantResponse.from(
      variantService.addEngine(new VariantId(id), new EngineId(engineId))
    );
  }

  public VariantResponse addMarket(@PathVariable UUID id, @PathVariable String market) {
    return VariantResponse.from(
      variantService.addMarket(new VariantId(id), market)
    );
  }

  public void deleteById(@PathVariable UUID id) {
    variantService.deleteById(new VariantId(id));
  }

public record VariantRequest(
  @NotNull UUID bodyId,
  @NotNull UUID transmissionId,
  @NotNull Drivetrain drivetrain,
  @Min(1) int curbWeightKg,
  @Min(1) Integer groundClearanceMm,
  @Min(1) Integer systemPowerKw
) {
}

public record VariantResponse(
  UUID id,
  UUID bodyId,
  Set<UUID> engineIds,
  UUID transmissionId,
  String drivetrain,
  Integer groundClearanceMm,
  int curbWeightKg,
  Integer systemPowerKw,
  Set<String> markets
) {
  public static VariantResponse from(Variant v) {
    return new VariantResponse(
      v.id().value(),
      v.bodyId().value(),
      v.engineIds().stream().map(EngineId::value).collect(Collectors.toSet()),
      v.transmissionId().value(),
      v.drivetrain().name(),
      v.groundClearanceMm(),
      v.curbWeightKg(),
      v.systemPowerKw(),
      v.markets()
    );
  }
}

public record VariantResponse(
  UUID id,
  UUID bodyId,
  Set<UUID> engineIds,
  UUID transmissionId,
  String drivetrain,
  Integer groundClearanceMm,
  int curbWeightKg,
  Integer systemPowerKw,
  Set<String> markets
) {
  public static VariantResponse from(Variant v) {
    return new VariantResponse(
      v.id().value(),
      v.bodyId().value(),
      v.engineIds().stream().map(EngineId::value).collect(Collectors.toSet()),
      v.transmissionId().value(),
      v.drivetrain().name(),
      v.groundClearanceMm(),
      v.curbWeightKg(),
      v.systemPowerKw(),
      v.markets()
    );
  }
}

  public static VariantResponse from(Variant v) {
    return new VariantResponse(
      v.id().value(),
      v.bodyId().value(),
      v.engineIds().stream().map(EngineId::value).collect(Collectors.toSet()),
      v.transmissionId().value(),
      v.drivetrain().name(),
      v.groundClearanceMm(),
      v.curbWeightKg(),
      v.systemPowerKw(),
      v.markets()
    );
  }

public class BodyService {

  private final BodyRepository bodyRepository;
  private final GenerationRepository generationRepository;

  public BodyService(BodyRepository bodyRepository, GenerationRepository generationRepository) {
    this.bodyRepository = bodyRepository;
    this.generationRepository = generationRepository;
  }

  public Body create(GenerationId generationId, BodyStyle bodyStyle,
                     int lengthMm, int widthMm, int heightMm, int wheelbaseMm,
                     Integer trunkVolumeLitres) {
    if (generationRepository.findById(generationId).isEmpty())
      throw new EntityNotFoundException("Generation not found: " + generationId.value());
    if (bodyRepository.existsByGenerationIdAndBodyStyle(generationId, bodyStyle))
      throw new IllegalStateException(
        "Body already exists for generation " + generationId.value() + " with style " + bodyStyle);
    var body = Body.create(generationId, bodyStyle, lengthMm, widthMm, heightMm, wheelbaseMm);

  public BodyService(BodyRepository bodyRepository, GenerationRepository generationRepository) {
    this.bodyRepository = bodyRepository;
    this.generationRepository = generationRepository;
  }

  public Body create(GenerationId generationId, BodyStyle bodyStyle,
                     int lengthMm, int widthMm, int heightMm, int wheelbaseMm,
                     Integer trunkVolumeLitres) {
    if (generationRepository.findById(generationId).isEmpty())
      throw new EntityNotFoundException("Generation not found: " + generationId.value());
    if (bodyRepository.existsByGenerationIdAndBodyStyle(generationId, bodyStyle))
      throw new IllegalStateException(
        "Body already exists for generation " + generationId.value() + " with style " + bodyStyle);
    var body = Body.create(generationId, bodyStyle, lengthMm, widthMm, heightMm, wheelbaseMm);
    if (trunkVolumeLitres != null) body.setTrunkVolumeLitres(trunkVolumeLitres);
    return bodyRepository.save(body);
  }

  public Body getById(BodyId id) {
    return bodyRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException("Body not found: " + id.value()));
  }

  public List<Body> getByGeneration(GenerationId generationId) {
    return bodyRepository.findByGenerationId(generationId);
  }

  public void deleteById(BodyId id) {
    getById(id);
    bodyRepository.deleteById(id);
  }

public class EngineService {

  private final EngineRepository engineRepository;

  public EngineService(EngineRepository engineRepository) {
    this.engineRepository = engineRepository;
  }

  public Engine create(String code, String name, FuelType fuelType,
                       int displacementCc, int powerKw, int torqueNm,
                       Integer cylinderCount, String configuration,
                       Integer systemPowerKw) {
    if (engineRepository.existsByCode(code))
      throw new IllegalStateException("Engine already exists: " + code);
    var engine = Engine.create(code, name, fuelType, displacementCc, powerKw, torqueNm);
    if (cylinderCount != null) engine.setCylinderCount(cylinderCount);
    if (configuration != null) engine.setConfiguration(configuration);
    if (systemPowerKw != null) engine.setSystemPowerKw(systemPowerKw);
    return engineRepository.save(engine);
  }

  public Engine getById(EngineId id) {
    return engineRepository.findById(id)
      

  public EngineService(EngineRepository engineRepository) {
    this.engineRepository = engineRepository;
  }

  public Engine create(String code, String name, FuelType fuelType,
                       int displacementCc, int powerKw, int torqueNm,
                       Integer cylinderCount, String configuration,
                       Integer systemPowerKw) {
    if (engineRepository.existsByCode(code))
      throw new IllegalStateException("Engine already exists: " + code);
    var engine = Engine.create(code, name, fuelType, displacementCc, powerKw, torqueNm);
    if (cylinderCount != null) engine.setCylinderCount(cylinderCount);
    if (configuration != null) engine.setConfiguration(configuration);
    if (systemPowerKw != null) engine.setSystemPowerKw(systemPowerKw);
    return engineRepository.save(engine);
  }

  public Engine getById(EngineId id) {
    return engineRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException("Engine not found: " + id.value()));
  }

  public List<Engine> getAll() {
    return engineRepository.findAll();
  }

  public List<Engine> getByFuelType(FuelType fuelType) {
    return engineRepository.findByFuelType(fuelType);
  }

public class GenerationService {

  private final GenerationRepository generationRepository;
  private final CarModelRepository modelRepository;

  public GenerationService(GenerationRepository generationRepository,
                           CarModelRepository modelRepository) {
    this.generationRepository = generationRepository;
    this.modelRepository = modelRepository;
  }

  public Generation create(ModelId modelId, String name, YearRange years) {
    if (modelRepository.findById(modelId).isEmpty())
      throw new EntityNotFoundException("Model not found: " + modelId.value());
    if (generationRepository.existsByModelIdAndName(modelId, name))
      throw new IllegalStateException("Generation already exists for model " + modelId.value() + ": " + name);
    return generationRepository.save(Generation.create(modelId, name, years));
  }

  public Generation getById(GenerationId id) {
    return generationRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException

  public GenerationService(GenerationRepository generationRepository,
                           CarModelRepository modelRepository) {
    this.generationRepository = generationRepository;
    this.modelRepository = modelRepository;
  }

  public Generation create(ModelId modelId, String name, YearRange years) {
    if (modelRepository.findById(modelId).isEmpty())
      throw new EntityNotFoundException("Model not found: " + modelId.value());
    if (generationRepository.existsByModelIdAndName(modelId, name))
      throw new IllegalStateException("Generation already exists for model " + modelId.value() + ": " + name);
    return generationRepository.save(Generation.create(modelId, name, years));
  }

  public Generation getById(GenerationId id) {
    return generationRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException("Generation not found: " + id.value()));
  }

  public List<Generation> getByModel(ModelId modelId) {
    return generationRepository.findByModelId(modelId);
  }

  public Generation close(GenerationId generationId, int year) {
    var generation = getById(generationId);
    generation.close(year);
    return generationRepository.save(generation);
  }

public class MakeService {

  private final MakeRepository makeRepository;

  public MakeService(MakeRepository makeRepository) {
    this.makeRepository = makeRepository;
  }

  public Make create(String name, String country) {
    if (makeRepository.existsByName(name))
      throw new IllegalStateException("Make already exists: " + name);
    return makeRepository.save(Make.create(name, country));
  }

  public Make getById(MakeId id) {
    return makeRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException("Make not found: " + id.value()));
  }

  public Make getBySlug(String slug) {
    return makeRepository.findBySlug(slug)
      .orElseThrow(() -> new EntityNotFoundException("Make not found: " + slug));
  }

  public List<Make> getAll() {
    return makeRepository.findAll();
  }

  public Make rename(MakeId id, String newName) {
    var make = getById(id);
    make.rename(newName);
    return makeRepository.save(make);
  }
}

  public MakeService(MakeRepository makeRepository) {
    this.makeRepository = makeRepository;
  }

  public Make create(String name, String country) {
    if (makeRepository.existsByName(name))
      throw new IllegalStateException("Make already exists: " + name);
    return makeRepository.save(Make.create(name, country));
  }

  public Make getById(MakeId id) {
    return makeRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException("Make not found: " + id.value()));
  }

  public Make getBySlug(String slug) {
    return makeRepository.findBySlug(slug)
      .orElseThrow(() -> new EntityNotFoundException("Make not found: " + slug));
  }