Function bodies 391 total

public class BodyController {

  private final BodyService bodyService;

  public BodyController(BodyService bodyService) {
    this.bodyService = bodyService;
  }

  @GetMapping
  @Operation(summary = "Get bodies by generation")
  public List<BodyResponse> getByGeneration(@RequestParam UUID generationId) {
    return bodyService.getByGeneration(new GenerationId(generationId)).stream()
      .map(BodyResponse::from).toList();
  }

  @GetMapping("/{id}")
  @Operation(summary = "Get body by ID")
  public BodyResponse getById(@PathVariable UUID id) {
    return BodyResponse.from(bodyService.getById(new BodyId(id)));
  }

  @PostMapping
  @Operation(summary = "Create a new body configuration")
  public ResponseEntity<BodyResponse> create(@Valid @RequestBody BodyRequest request) {
    var body = bodyService.create(
      new GenerationId(request.generationId()),
      request.bodyStyle(),
      request.lengthMm(),
      request.widthMm(),
      request.heightMm(),
      request.wheelbaseMm(

  public BodyController(BodyService bodyService) {
    this.bodyService = bodyService;
  }

  public List<BodyResponse> getByGeneration(@RequestParam UUID generationId) {
    return bodyService.getByGeneration(new GenerationId(generationId)).stream()
      .map(BodyResponse::from).toList();
  }

  public BodyResponse getById(@PathVariable UUID id) {
    return BodyResponse.from(bodyService.getById(new BodyId(id)));
  }

  public ResponseEntity<BodyResponse> create(@Valid @RequestBody BodyRequest request) {
    var body = bodyService.create(
      new GenerationId(request.generationId()),
      request.bodyStyle(),
      request.lengthMm(),
      request.widthMm(),
      request.heightMm(),
      request.wheelbaseMm(),
      request.trunkVolumeLitres()
    );
    var uri = ServletUriComponentsBuilder.fromCurrentRequest()
      .path("/{id}").buildAndExpand(body.id().value()).toUri();
    return ResponseEntity.created(uri).body(BodyResponse.from(body));
  }

  public void deleteById(@PathVariable UUID id) {
    bodyService.deleteById(new BodyId(id));
  }

public record BodyRequest(
  @NotNull UUID generationId,
  @NotNull BodyStyle bodyStyle,
  @Min(1) int lengthMm,
  @Min(1) int widthMm,
  @Min(1) int heightMm,
  @Min(1) int wheelbaseMm,
  @Min(1) Integer trunkVolumeLitres
) {
}

public record BodyResponse(
  UUID id,
  UUID generationId,
  String bodyStyle,
  int lengthMm,
  int widthMm,
  int heightMm,
  int wheelbaseMm,
  Integer trunkVolumeLitres
) {
  public static BodyResponse from(Body b) {
    return new BodyResponse(
      b.id().value(),
      b.generationId().value(),
      b.bodyStyle().name(),
      b.lengthMm(),
      b.widthMm(),
      b.heightMm(),
      b.wheelbaseMm(),
      b.trunkVolumeLitres()
    );
  }
}

public record BodyResponse(
  UUID id,
  UUID generationId,
  String bodyStyle,
  int lengthMm,
  int widthMm,
  int heightMm,
  int wheelbaseMm,
  Integer trunkVolumeLitres
) {
  public static BodyResponse from(Body b) {
    return new BodyResponse(
      b.id().value(),
      b.generationId().value(),
      b.bodyStyle().name(),
      b.lengthMm(),
      b.widthMm(),
      b.heightMm(),
      b.wheelbaseMm(),
      b.trunkVolumeLitres()
    );
  }
}

  public static BodyResponse from(Body b) {
    return new BodyResponse(
      b.id().value(),
      b.generationId().value(),
      b.bodyStyle().name(),
      b.lengthMm(),
      b.widthMm(),
      b.heightMm(),
      b.wheelbaseMm(),
      b.trunkVolumeLitres()
    );
  }

public class EngineController {

  private final EngineService engineService;

  public EngineController(EngineService engineService) {
    this.engineService = engineService;
  }

  @GetMapping
  @Operation(summary = "Get all engines")
  public List<EngineResponse> getAll(@RequestParam(required = false) FuelType fuelType) {
    var engines = fuelType != null
      ? engineService.getByFuelType(fuelType)
      : engineService.getAll();
    return engines.stream().map(EngineResponse::from).toList();
  }

  @GetMapping("/{id}")
  @Operation(summary = "Get engine by ID")
  public EngineResponse getById(@PathVariable UUID id) {
    return EngineResponse.from(engineService.getById(new EngineId(id)));
  }

  @PostMapping
  @Operation(summary = "Create a new engine")
  public ResponseEntity<EngineResponse> create(@Valid @RequestBody EngineRequest request) {
    var engine = engineService.create(
      request.code(), request.name(), request.fuelType(),
      request.displacementCc(), request.

  public EngineController(EngineService engineService) {
    this.engineService = engineService;
  }

  public EngineResponse getById(@PathVariable UUID id) {
    return EngineResponse.from(engineService.getById(new EngineId(id)));
  }

  public ResponseEntity<EngineResponse> create(@Valid @RequestBody EngineRequest request) {
    var engine = engineService.create(
      request.code(), request.name(), request.fuelType(),
      request.displacementCc(), request.powerKw(), request.torqueNm(),
      request.cylinderCount(), request.configuration(), request.systemPowerKw()
    );
    var uri = ServletUriComponentsBuilder.fromCurrentRequest()
      .path("/{id}").buildAndExpand(engine.id().value()).toUri();
    return ResponseEntity.created(uri).body(EngineResponse.from(engine));
  }

public record EngineRequest(
  @NotBlank @Size(max = 50) String code,
  @NotBlank @Size(max = 150) String name,
  @NotNull FuelType fuelType,
  @Positive int displacementCc,
  @Positive int powerKw,
  @Positive int torqueNm,
  @Min(1) @Max(16) Integer cylinderCount,
  @Size(max = 20) String configuration,
  @Positive Integer systemPowerKw
) {
}

public record EngineResponse(
  UUID id,
  String code,
  String name,
  String fuelType,
  int displacementCc,
  int powerKw,
  int powerHp,
  int torqueNm,
  Integer cylinderCount,
  String configuration,
  Integer systemPowerKw
) {
  public static EngineResponse from(Engine engine) {
    return new EngineResponse(
      engine.id().value(), engine.code(), engine.name(), engine.fuelType().name(),
      engine.displacementCc(), engine.powerKw(), engine.powerHp(),
      engine.torqueNm(), engine.cylinderCount(), engine.configuration(),
      engine.systemPowerKw()
    );
  }
}

public record EngineResponse(
  UUID id,
  String code,
  String name,
  String fuelType,
  int displacementCc,
  int powerKw,
  int powerHp,
  int torqueNm,
  Integer cylinderCount,
  String configuration,
  Integer systemPowerKw
) {
  public static EngineResponse from(Engine engine) {
    return new EngineResponse(
      engine.id().value(), engine.code(), engine.name(), engine.fuelType().name(),
      engine.displacementCc(), engine.powerKw(), engine.powerHp(),
      engine.torqueNm(), engine.cylinderCount(), engine.configuration(),
      engine.systemPowerKw()
    );
  }
}

  public static EngineResponse from(Engine engine) {
    return new EngineResponse(
      engine.id().value(), engine.code(), engine.name(), engine.fuelType().name(),
      engine.displacementCc(), engine.powerKw(), engine.powerHp(),
      engine.torqueNm(), engine.cylinderCount(), engine.configuration(),
      engine.systemPowerKw()
    );
  }

public class GenerationController {

  private final GenerationService generationService;

  public GenerationController(GenerationService generationService) {
    this.generationService = generationService;
  }

  @GetMapping
  @Operation(summary = "Get generations by model")
  public List<GenerationResponse> getByModel(@RequestParam UUID modelId) {
    return generationService.getByModel(new ModelId(modelId)).stream()
      .map(GenerationResponse::from).toList();
  }

  @GetMapping("/{id}")
  @Operation(summary = "Get generation by ID")
  public GenerationResponse getById(@PathVariable UUID id) {
    return GenerationResponse.from(generationService.getById(new GenerationId(id)));
  }

  @PostMapping
  @Operation(summary = "Create a new generation")
  public ResponseEntity<GenerationResponse> create(@Valid @RequestBody GenerationRequest request) {
    var generation = generationService.create(
      new ModelId(request.modelId()),
      request.name(),
      new YearRange(request.yea

  public GenerationController(GenerationService generationService) {
    this.generationService = generationService;
  }

  public List<GenerationResponse> getByModel(@RequestParam UUID modelId) {
    return generationService.getByModel(new ModelId(modelId)).stream()
      .map(GenerationResponse::from).toList();
  }

  public GenerationResponse getById(@PathVariable UUID id) {
    return GenerationResponse.from(generationService.getById(new GenerationId(id)));
  }

  public ResponseEntity<GenerationResponse> create(@Valid @RequestBody GenerationRequest request) {
    var generation = generationService.create(
      new ModelId(request.modelId()),
      request.name(),
      new YearRange(request.yearFrom(), request.yearTo())
    );
    var uri = ServletUriComponentsBuilder.fromCurrentRequest()
      .path("/{id}").buildAndExpand(generation.id().value()).toUri();
    return ResponseEntity.created(uri).body(GenerationResponse.from(generation));
  }

  public GenerationResponse close(@PathVariable UUID id, @RequestParam int year) {
    return GenerationResponse.from(generationService.close(new GenerationId(id), year));
  }

public record GenerationRequest(
  @NotNull UUID modelId,
  @NotBlank @Size(max = 50) String name,
  @Min(1886) @Max(2100) int yearFrom,
  Integer yearTo
) {
}

public record GenerationResponse(
  UUID id,
  UUID modelId,
  String name,
  int yearFrom,
  Integer yearTo
) {
  public static GenerationResponse from(Generation g) {
    return new GenerationResponse(
      g.id().value(),
      g.modelId().value(),
      g.name(),
      g.years().from(),
      g.years().to()
    );
  }
}

public record GenerationResponse(
  UUID id,
  UUID modelId,
  String name,
  int yearFrom,
  Integer yearTo
) {
  public static GenerationResponse from(Generation g) {
    return new GenerationResponse(
      g.id().value(),
      g.modelId().value(),
      g.name(),
      g.years().from(),
      g.years().to()
    );
  }
}

  public static GenerationResponse from(Generation g) {
    return new GenerationResponse(
      g.id().value(),
      g.modelId().value(),
      g.name(),
      g.years().from(),
      g.years().to()
    );
  }

public class MakeController {

  private final MakeService makeService;

  public MakeController(MakeService makeService) {
    this.makeService = makeService;
  }

  @GetMapping
  @Operation(summary = "Get all makes")
  public List<MakeResponse> getAll() {
    return makeService.getAll().stream().map(MakeResponse::from).toList();
  }

  @GetMapping("/{id}")
  @Operation(summary = "Get make by ID")
  public MakeResponse getById(@PathVariable UUID id) {
    return MakeResponse.from(makeService.getById(MakeId.of(id.toString())));
  }

  @GetMapping("/slug/{slug}")
  @Operation(summary = "Get make by slug")
  public MakeResponse getBySlug(@PathVariable String slug) {
    return MakeResponse.from(makeService.getBySlug(slug));
  }

  @PostMapping
  @Operation(summary = "Create a new make")
  public ResponseEntity<MakeResponse> create(@Valid @RequestBody MakeRequest request) {
    var make = makeService.create(request.name(), request.country());
    var uri = ServletUriComponentsBuilder.from

  public MakeController(MakeService makeService) {
    this.makeService = makeService;
  }

  public List<MakeResponse> getAll() {
    return makeService.getAll().stream().map(MakeResponse::from).toList();
  }

  public MakeResponse getById(@PathVariable UUID id) {
    return MakeResponse.from(makeService.getById(MakeId.of(id.toString())));
  }

  public MakeResponse getBySlug(@PathVariable String slug) {
    return MakeResponse.from(makeService.getBySlug(slug));
  }

  public ResponseEntity<MakeResponse> create(@Valid @RequestBody MakeRequest request) {
    var make = makeService.create(request.name(), request.country());
    var uri = ServletUriComponentsBuilder.fromCurrentRequest()
      .path("/{id}").buildAndExpand(make.id().value()).toUri();
    return ResponseEntity.created(uri).body(MakeResponse.from(make));
  }

  public MakeResponse rename(@PathVariable UUID id, @Valid @RequestBody MakeRequest request) {
    return MakeResponse.from(makeService.rename(MakeId.of(id.toString()), request.name()));
  }

public record MakeRequest(
  @NotBlank @Size(max = 100) String name,
  @NotBlank @Size(max = 100) String country
) {
}

public record MakeResponse(UUID id, String name, String country, String slug) {

  public static MakeResponse from(Make make) {
    return new MakeResponse(make.id().value(), make.name(), make.country(), make.slug());
  }
}

public record MakeResponse(UUID id, String name, String country, String slug) {

  public static MakeResponse from(Make make) {
    return new MakeResponse(make.id().value(), make.name(), make.country(), make.slug());
  }
}

  public static MakeResponse from(Make make) {
    return new MakeResponse(make.id().value(), make.name(), make.country(), make.slug());
  }

public class CarModelController {

  private final CarModelService carModelService;

  public CarModelController(CarModelService carModelService) {
    this.carModelService = carModelService;
  }

  @GetMapping
  @Operation(summary = "Get models by make")
  public List<CarModelResponse> getByMake(@RequestParam UUID makeId) {
    return carModelService.getByMake(new MakeId(makeId)).stream()
      .map(CarModelResponse::from).toList();
  }

  @GetMapping("/{id}")
  @Operation(summary = "Get model by ID")
  public CarModelResponse getById(@PathVariable UUID id) {
    return CarModelResponse.from(carModelService.getById(new ModelId(id)));
  }

  @PostMapping
  @Operation(summary = "Create a new model")
  public ResponseEntity<CarModelResponse> create(@Valid @RequestBody CarModelRequest request) {
    var model = carModelService.create(new MakeId(request.makeId()), request.name());
    var uri = ServletUriComponentsBuilder.fromCurrentRequest()
      .path("/{id}").buildAndExpand(model.id().

  public CarModelController(CarModelService carModelService) {
    this.carModelService = carModelService;
  }

  public List<CarModelResponse> getByMake(@RequestParam UUID makeId) {
    return carModelService.getByMake(new MakeId(makeId)).stream()
      .map(CarModelResponse::from).toList();
  }

  public CarModelResponse getById(@PathVariable UUID id) {
    return CarModelResponse.from(carModelService.getById(new ModelId(id)));
  }

  public ResponseEntity<CarModelResponse> create(@Valid @RequestBody CarModelRequest request) {
    var model = carModelService.create(new MakeId(request.makeId()), request.name());
    var uri = ServletUriComponentsBuilder.fromCurrentRequest()
      .path("/{id}").buildAndExpand(model.id().value()).toUri();
    return ResponseEntity.created(uri).body(CarModelResponse.from(model));
  }

  public CarModelResponse addRelation(@PathVariable UUID id,
                                      @Valid @RequestBody ModelRelationRequest request) {
    return CarModelResponse.from(carModelService.linkRelation(
      new ModelId(id), new ModelId(request.targetModelId()), request.type(), request.note()
    ));
  }

public record CarModelRequest(
  @NotNull UUID makeId,
  @NotBlank @Size(max = 100) String name
) {
}

public record CarModelResponse(
  UUID id,
  UUID makeId,
  String name,
  String slug,
  List<RelationResponse> relations
) {
  public static CarModelResponse from(CarModel model) {
    return new CarModelResponse(
      model.id().value(),
      model.makeId().value(),
      model.name(),
      model.slug(),
      model.relations().stream()
        .map(r -> new RelationResponse(r.targetModelId().value(), r.type().name(), r.note()))
        .toList()
    );
  }

  public record RelationResponse(UUID targetModelId, String type, String note) {
  }
}

public record CarModelResponse(
  UUID id,
  UUID makeId,
  String name,
  String slug,
  List<RelationResponse> relations
) {
  public static CarModelResponse from(CarModel model) {
    return new CarModelResponse(
      model.id().value(),
      model.makeId().value(),
      model.name(),
      model.slug(),
      model.relations().stream()
        .map(r -> new RelationResponse(r.targetModelId().value(), r.type().name(), r.note()))
        .toList()
    );
  }

  public record RelationResponse(UUID targetModelId, String type, String note) {
  }
}

  public static CarModelResponse from(CarModel model) {
    return new CarModelResponse(
      model.id().value(),
      model.makeId().value(),
      model.name(),
      model.slug(),
      model.relations().stream()
        .map(r -> new RelationResponse(r.targetModelId().value(), r.type().name(), r.note()))
        .toList()
    );
  }

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