Function bodies 391 total

  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 class CarModelService {

  private final CarModelRepository modelRepository;
  private final MakeRepository makeRepository;

  public CarModelService(CarModelRepository modelRepository, MakeRepository makeRepository) {
    this.modelRepository = modelRepository;
    this.makeRepository = makeRepository;
  }

  public CarModel create(MakeId makeId, String name) {
    if (makeRepository.findById(makeId).isEmpty())
      throw new EntityNotFoundException("Make not found: " + makeId.value());
    if (modelRepository.existsByMakeIdAndName(makeId, name))
      throw new IllegalStateException("Model already exists for make " + makeId.value() + ": " + name);
    return modelRepository.save(CarModel.create(makeId, name));
  }

  public CarModel getById(ModelId id) {
    return modelRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException("Model not found: " + id.value()));
  }

  public List<CarModel> getByMake(MakeId makeId) {
    return modelRepository.findByMakeId(

  public CarModelService(CarModelRepository modelRepository, MakeRepository makeRepository) {
    this.modelRepository = modelRepository;
    this.makeRepository = makeRepository;
  }

  public CarModel create(MakeId makeId, String name) {
    if (makeRepository.findById(makeId).isEmpty())
      throw new EntityNotFoundException("Make not found: " + makeId.value());
    if (modelRepository.existsByMakeIdAndName(makeId, name))
      throw new IllegalStateException("Model already exists for make " + makeId.value() + ": " + name);
    return modelRepository.save(CarModel.create(makeId, name));
  }

  public CarModel getById(ModelId id) {
    return modelRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException("Model not found: " + id.value()));
  }

  public List<CarModel> getByMake(MakeId makeId) {
    return modelRepository.findByMakeId(makeId);
  }

  public CarModel linkRelation(ModelId fromId, ModelId toId,
                               ModelRelation.Type type, String note) {
    var from = getById(fromId);
    getById(toId);
    from.addRelation(toId, type, note);
    return modelRepository.save(from);
  }

public class EntityNotFoundException extends RuntimeException {
  public EntityNotFoundException(String message) {
    super(message);
  }
}

  public EntityNotFoundException(String message) {
    super(message);
  }

public class TransmissionService {

  private final TransmissionRepository transmissionRepository;

  public TransmissionService(TransmissionRepository transmissionRepository) {
    this.transmissionRepository = transmissionRepository;
  }

  public Transmission create(TransmissionType type, int gearCount) {
    if (transmissionRepository.existsByTypeAndGearCount(type, gearCount))
      throw new IllegalStateException("Transmission already exists: " + type + " " + gearCount + "-speed");
    return transmissionRepository.save(Transmission.create(type, gearCount));
  }

  public Transmission getById(TransmissionId id) {
    return transmissionRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException("Transmission not found: " + id.value()));
  }

  public List<Transmission> getAll() {
    return transmissionRepository.findAll();
  }

  public List<Transmission> getByType(TransmissionType type) {
    return transmissionRepository.findByType(type);
  }
}

  public TransmissionService(TransmissionRepository transmissionRepository) {
    this.transmissionRepository = transmissionRepository;
  }

  public Transmission create(TransmissionType type, int gearCount) {
    if (transmissionRepository.existsByTypeAndGearCount(type, gearCount))
      throw new IllegalStateException("Transmission already exists: " + type + " " + gearCount + "-speed");
    return transmissionRepository.save(Transmission.create(type, gearCount));
  }

  public Transmission getById(TransmissionId id) {
    return transmissionRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException("Transmission not found: " + id.value()));
  }

  public List<Transmission> getAll() {
    return transmissionRepository.findAll();
  }

  public List<Transmission> getByType(TransmissionType type) {
    return transmissionRepository.findByType(type);
  }

public class VariantService {

  private final VariantRepository variantRepository;
  private final BodyRepository bodyRepository;
  private final EngineRepository engineRepository;
  private final TransmissionRepository transmissionRepository;

  public VariantService(VariantRepository variantRepository,
                        BodyRepository bodyRepository,
                        EngineRepository engineRepository,
                        TransmissionRepository transmissionRepository) {
    this.variantRepository = variantRepository;
    this.bodyRepository = bodyRepository;
    this.engineRepository = engineRepository;
    this.transmissionRepository = transmissionRepository;
  }

  public Variant create(BodyId bodyId, TransmissionId transmissionId,
                        Drivetrain drivetrain, int curbWeightKg,
                        Integer groundClearanceMm, Integer systemPowerKw) {
    if (bodyRepository.findById(bodyId).isEmpty())
      throw new EntityNotFoundException("Body

  public VariantService(VariantRepository variantRepository,
                        BodyRepository bodyRepository,
                        EngineRepository engineRepository,
                        TransmissionRepository transmissionRepository) {
    this.variantRepository = variantRepository;
    this.bodyRepository = bodyRepository;
    this.engineRepository = engineRepository;
    this.transmissionRepository = transmissionRepository;
  }

  public Variant create(BodyId bodyId, TransmissionId transmissionId,
                        Drivetrain drivetrain, int curbWeightKg,
                        Integer groundClearanceMm, Integer systemPowerKw) {
    if (bodyRepository.findById(bodyId).isEmpty())
      throw new EntityNotFoundException("Body not found: " + bodyId.value());
    if (transmissionRepository.findById(transmissionId).isEmpty())
      throw new EntityNotFoundException("Transmission not found: " + transmissionId.value());
    if (variantRepository.existsByBodyIdAndTransmissionIdAndDrivetrain(bodyId, transmissionId, drivetrain))
      throw new IllegalStateException(
        "Variant already exists for body " + bodyId.value()
          + " with transmission " + transmissionId.value()
          + " and drivetrain " + drivetrain);
    var variant = Variant.create(bodyId, transmissionId, drivetrain, curbWeightKg);
    if (groundClearanceMm != null) variant.setGroundClearanceMm(groundClearanceMm);
    if (systemPower

  public Variant getById(VariantId id) {
    return variantRepository.findById(id)
      .orElseThrow(() -> new EntityNotFoundException("Variant not found: " + id.value()));
  }

  public List<Variant> getByBody(BodyId bodyId) {
    return variantRepository.findByBodyId(bodyId);
  }

  public Variant addEngine(VariantId variantId, EngineId engineId) {
    var variant = getById(variantId);
    if (engineRepository.findById(engineId).isEmpty())
      throw new EntityNotFoundException("Engine not found: " + engineId.value());
    variant.addEngine(engineId);
    return variantRepository.save(variant);
  }

  public Variant addMarket(VariantId variantId, String market) {
    var variant = getById(variantId);
    variant.addMarket(market);
    return variantRepository.save(variant);
  }

  public void deleteById(VariantId id) {
    getById(id);
    variantRepository.deleteById(id);
  }

public class AutocatalogApplication {

  public static void main(String[] args) {
    SpringApplication.run(AutocatalogApplication.class, args);
  }

}

  public static void main(String[] args) {
    SpringApplication.run(AutocatalogApplication.class, args);
  }

public record BodyId(UUID value) {
  public BodyId {
    Objects.requireNonNull(value, "BodyId value must not be null");
  }

  public static BodyId generate() {
    return new BodyId(UUID.randomUUID());
  }

  public static BodyId of(String value) {
    return new BodyId(UUID.fromString(value));
  }
}

public record BodyId(UUID value) {
  public BodyId {
    Objects.requireNonNull(value, "BodyId value must not be null");
  }

  public static BodyId generate() {
    return new BodyId(UUID.randomUUID());
  }

  public static BodyId of(String value) {
    return new BodyId(UUID.fromString(value));
  }
}

  public static BodyId generate() {
    return new BodyId(UUID.randomUUID());
  }

  public static BodyId of(String value) {
    return new BodyId(UUID.fromString(value));
  }

public class Body {

  private BodyId id;
  private GenerationId generationId;
  private BodyStyle bodyStyle;
  private int lengthMm;
  private int widthMm;
  private int heightMm;
  private int wheelbaseMm;
  private Integer trunkVolumeLitres;

  private Body() {
  }

  public static Body create(GenerationId generationId, BodyStyle bodyStyle,
                            int lengthMm, int widthMm, int heightMm, int wheelbaseMm) {
    validateDimensions(lengthMm, widthMm, heightMm, wheelbaseMm);
    var b = new Body();
    b.id = BodyId.generate();
    b.generationId = Objects.requireNonNull(generationId, "generationId must not be null");
    b.bodyStyle = Objects.requireNonNull(bodyStyle, "bodyStyle must not be null");
    b.lengthMm = lengthMm;
    b.widthMm = widthMm;
    b.heightMm = heightMm;
    b.wheelbaseMm = wheelbaseMm;
    return b;
  }

  public static Body reconstitute(BodyId id, GenerationId generationId, BodyStyle bodyStyle,
                                  int lengthMm,

  public static Body create(GenerationId generationId, BodyStyle bodyStyle,
                            int lengthMm, int widthMm, int heightMm, int wheelbaseMm) {
    validateDimensions(lengthMm, widthMm, heightMm, wheelbaseMm);
    var b = new Body();
    b.id = BodyId.generate();
    b.generationId = Objects.requireNonNull(generationId, "generationId must not be null");
    b.bodyStyle = Objects.requireNonNull(bodyStyle, "bodyStyle must not be null");
    b.lengthMm = lengthMm;
    b.widthMm = widthMm;
    b.heightMm = heightMm;
    b.wheelbaseMm = wheelbaseMm;
    return b;
  }

  public static Body reconstitute(BodyId id, GenerationId generationId, BodyStyle bodyStyle,
                                  int lengthMm, int widthMm, int heightMm, int wheelbaseMm,
                                  Integer trunkVolumeLitres) {
    var b = new Body();
    b.id = id;
    b.generationId = generationId;
    b.bodyStyle = bodyStyle;
    b.lengthMm = lengthMm;
    b.widthMm = widthMm;
    b.heightMm = heightMm;
    b.wheelbaseMm = wheelbaseMm;
    b.trunkVolumeLitres = trunkVolumeLitres;
    return b;
  }

  public void setTrunkVolumeLitres(int trunkVolumeLitres) {
    if (trunkVolumeLitres <= 0)
      throw new IllegalArgumentException("trunkVolumeLitres must be > 0");
    this.trunkVolumeLitres = trunkVolumeLitres;
  }

  public BodyId id() {
    return id;
  }

  public GenerationId generationId() {
    return generationId;
  }

  public BodyStyle bodyStyle() {
    return bodyStyle;
  }

  public int lengthMm() {
    return lengthMm;
  }

  public int widthMm() {
    return widthMm;
  }

  public int heightMm() {
    return heightMm;
  }

  public int wheelbaseMm() {
    return wheelbaseMm;
  }

  public Integer trunkVolumeLitres() {
    return trunkVolumeLitres;
  }

  private static void validateDimensions(int length, int width, int height, int wheelbase) {
    if (length <= 0) throw new IllegalArgumentException("lengthMm must be > 0");
    if (width <= 0) throw new IllegalArgumentException("widthMm must be > 0");
    if (height <= 0) throw new IllegalArgumentException("heightMm must be > 0");
    if (wheelbase <= 0) throw new IllegalArgumentException("wheelbaseMm must be > 0");
  }

public record EngineId(UUID value) {
  public EngineId {
    Objects.requireNonNull(value, "EngineId value must not be null");
  }

  public static EngineId generate() {
    return new EngineId(UUID.randomUUID());
  }

  public static EngineId of(String value) {
    return new EngineId(UUID.fromString(value));
  }
}

public record EngineId(UUID value) {
  public EngineId {
    Objects.requireNonNull(value, "EngineId value must not be null");
  }

  public static EngineId generate() {
    return new EngineId(UUID.randomUUID());
  }

  public static EngineId of(String value) {
    return new EngineId(UUID.fromString(value));
  }
}

  public static EngineId generate() {
    return new EngineId(UUID.randomUUID());
  }

  public static EngineId of(String value) {
    return new EngineId(UUID.fromString(value));
  }

public class Engine {

  private EngineId id;
  private String code;
  private String name;
  private FuelType fuelType;
  private int displacementCc;
  private int powerKw;
  private int torqueNm;
  private Integer cylinderCount;
  private String configuration;
  private Integer systemPowerKw;

  private Engine() {
  }

  public static Engine create(String code, String name, FuelType fuelType,
                              int displacementCc, int powerKw, int torqueNm) {
    validate(displacementCc, powerKw, torqueNm);
    var e = new Engine();
    e.id = EngineId.generate();
    e.code = requireNonBlank(code, "code");
    e.name = requireNonBlank(name, "name");
    e.fuelType = Objects.requireNonNull(fuelType);
    e.displacementCc = displacementCc;
    e.powerKw = powerKw;
    e.torqueNm = torqueNm;
    return e;
  }

  public static Engine reconstitute(EngineId id, String code, String name, FuelType fuelType,
                                    int displacementCc, int powerKw, int 

  public static Engine create(String code, String name, FuelType fuelType,
                              int displacementCc, int powerKw, int torqueNm) {
    validate(displacementCc, powerKw, torqueNm);
    var e = new Engine();
    e.id = EngineId.generate();
    e.code = requireNonBlank(code, "code");
    e.name = requireNonBlank(name, "name");
    e.fuelType = Objects.requireNonNull(fuelType);
    e.displacementCc = displacementCc;
    e.powerKw = powerKw;
    e.torqueNm = torqueNm;
    return e;
  }

  public static Engine reconstitute(EngineId id, String code, String name, FuelType fuelType,
                                    int displacementCc, int powerKw, int torqueNm,
                                    Integer cylinderCount, String configuration,
                                    Integer systemPowerKw) {
    var e = new Engine();
    e.id = id;
    e.code = code;
    e.name = name;
    e.fuelType = fuelType;
    e.displacementCc = displacementCc;
    e.powerKw = powerKw;
    e.torqueNm = torqueNm;
    e.cylinderCount = cylinderCount;
    e.configuration = configuration;
    e.systemPowerKw = systemPowerKw;
    return e;
  }