Feature/implement biulding module 139

src/main/java/org/unilab/uniplan/building/Building.java

@@ -0,0 +1,33 @@
+package org.unilab.uniplan.building;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.unilab.uniplan.common.model.BaseEntity;
+import org.unilab.uniplan.university.University;
+
+@Entity
+@Table(name = "building")
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class Building extends BaseEntity {
+
+    @Column(name = "name", nullable = false, length = 50)
+    private String name;
+
+    @Column(name = "address", nullable = false, length = 100)
+    private String address;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "university_id", referencedColumnName = "id")
+    private University university;
+}

src/main/java/org/unilab/uniplan/building/BuildingController.java

@@ -0,0 +1,58 @@
+package org.unilab.uniplan.building;
+
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.unilab.uniplan.building.dto.BuildingRequestDto;
+import org.unilab.uniplan.building.dto.BuildingResponseDto;
+import java.util.List;
+import java.util.UUID;
+
+@RestController
+@RequestMapping("/buildings")
+@RequiredArgsConstructor
+@Tag(name = "Buildings", description = "Manage university buildings, including name, address, and associated university")
+public class BuildingController {
+    private final BuildingWebFacade buildingWebFacade;
+
+    @PostMapping
+    public ResponseEntity<Void> createBuilding(@Valid @NotNull @RequestBody final BuildingRequestDto buildingRequestDto) {
+        buildingWebFacade.createBuilding(buildingRequestDto);
+        return ResponseEntity.status(HttpStatus.CREATED).build();
+    }
+
+    @GetMapping
+    public ResponseEntity<List<BuildingResponseDto>> getAllBuildings() {
+        return ResponseEntity.ok(buildingWebFacade.getAllBuildings());
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<BuildingResponseDto> getBuildingById(@PathVariable final UUID id) {
+        return ResponseEntity.ok(buildingWebFacade.getBuildingById(id));
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Void> updateBuilding(
+        @PathVariable final UUID id,
+        @Valid @NotNull @RequestBody final BuildingRequestDto buildingRequestDto) {
+        buildingWebFacade.updateBuilding(id, buildingRequestDto);
+        return ResponseEntity.noContent().build();
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteBuilding(@PathVariable final UUID id) {
+        buildingWebFacade.deleteBuilding(id);
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/org/unilab/uniplan/building/BuildingMapper.java

@@ -0,0 +1,26 @@
+package org.unilab.uniplan.building;
+
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.MappingTarget;
+import org.unilab.uniplan.building.dto.BuildingRequestDto;
+import org.unilab.uniplan.building.dto.BuildingResponseDto;
+import java.util.List;
+
+@Mapper
+public interface BuildingMapper {
+    @Mapping(target = "id", ignore = true)
+    @Mapping(target = "university", ignore = true)
+    Building toEntity(final BuildingRequestDto buildingRequestDto);
+
+    @Mapping(source = "university.id", target = "universityId")
+    @Mapping(source = "university.uniName", target = "universityName")
+    BuildingResponseDto toResponseDto(final Building building);
+
+    List<BuildingResponseDto> toResponseDtoList(final List<Building> buildings);
+
+    @Mapping(target = "id", ignore = true)
+    @Mapping(target = "university", ignore = true)
+    void updateEntityFromDto(final BuildingRequestDto buildingRequestDto,
+                             @MappingTarget final Building building);
+}

src/main/java/org/unilab/uniplan/building/BuildingRepository.java

@@ -0,0 +1,10 @@
+package org.unilab.uniplan.building;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import java.util.UUID;
+
+@Repository
+public interface BuildingRepository extends JpaRepository<Building, UUID> {
+
+}

src/main/java/org/unilab/uniplan/building/BuildingService.java

@@ -0,0 +1,35 @@
+package org.unilab.uniplan.building;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.unilab.uniplan.common.model.BaseService;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+@Service
+@RequiredArgsConstructor
+public class BuildingService implements BaseService<Building> {
+
+    private final BuildingRepository buildingRepository;
+
+    @Override
+    public void save(final Building building) {
+        buildingRepository.save(building);
+    }
+
+    @Override
+    public List<Building> getAll() {
+        return buildingRepository.findAll();
+    }
+
+    @Override
+    public Optional<Building> getById(final UUID id) {
+        return buildingRepository.findById(id);
+    }
+
+    @Override
+    public void delete(Building building) {
+        buildingRepository.delete(building);
+    }
+}

src/main/java/org/unilab/uniplan/building/BuildingValidator.java

@@ -0,0 +1,29 @@
+package org.unilab.uniplan.building;
+
+import static org.unilab.uniplan.utils.ErrorConstants.UNIVERSITY_NOT_FOUND;
+
+import java.util.UUID;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.unilab.uniplan.building.dto.BuildingRequestDto;
+import org.unilab.uniplan.exception.ResourceNotFoundException;
+import org.unilab.uniplan.university.UniversityRepository;
+
+@Component
+@RequiredArgsConstructor
+public class BuildingValidator {
+
+    private final UniversityRepository universityRepository;
+
+    public void validate(final BuildingRequestDto requestDto) {
+        validateUniversityExists(requestDto.universityId());
+    }
+
+    private void validateUniversityExists(final UUID universityId) {
+        if (!universityRepository.existsById(universityId)) {
+            throw new ResourceNotFoundException(
+                UNIVERSITY_NOT_FOUND.getMessage(String.valueOf(universityId))
+            );
+        }
+    }
+}

src/main/java/org/unilab/uniplan/building/BuildingWebFacade.java

@@ -0,0 +1,79 @@
+package org.unilab.uniplan.building;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import org.unilab.uniplan.building.dto.BuildingRequestDto;
+import org.unilab.uniplan.building.dto.BuildingResponseDto;
+import org.unilab.uniplan.exception.ResourceNotFoundException;
+import org.unilab.uniplan.university.University;
+import org.unilab.uniplan.university.UniversityService;
+import java.util.List;
+import java.util.UUID;
+
+import static org.unilab.uniplan.utils.ErrorConstants.BUILDING_NOT_FOUND;
+import static org.unilab.uniplan.utils.ErrorConstants.UNIVERSITY_NOT_FOUND;
+
+@Component
+@Slf4j
+@RequiredArgsConstructor
+public class BuildingWebFacade {
+    private final BuildingService buildingService;
+    private final BuildingMapper buildingMapper;
+    private final UniversityService universityService;
+    private final BuildingValidator buildingValidator;
+
+    @Transactional
+    public void createBuilding(final BuildingRequestDto request) {
+        buildingValidator.validate(request);
+
+        final Building building = buildingMapper.toEntity(request);
+        building.setUniversity(getUniversityOrThrow(request.universityId()));
+        buildingService.save(building);
+
+        log.info("created building with ID: {}", building.getId());
+    }
+
+    @Transactional
+    public void updateBuilding(final UUID id, final BuildingRequestDto request) {
+        buildingValidator.validate(request);
+
+        final Building building = getBuildingOrThrow(id);
+        buildingMapper.updateEntityFromDto(request, building);
+        building.setUniversity(getUniversityOrThrow(request.universityId()));
+        buildingService.save(building);
+        log.info("updated building with ID: {}", building.getId());
+    }
+
+    @Transactional(readOnly = true)
+    public BuildingResponseDto getBuildingById(final UUID id) {
+        final Building building = getBuildingOrThrow(id);
+        return buildingMapper.toResponseDto(building);
+    }
+
+    @Transactional
+    public void deleteBuilding(final UUID id) {
+        final Building building = getBuildingOrThrow(id);
+        buildingService.delete(building);
+        log.info("deleted building with ID: {}", id);
+    }
+
+    @Transactional(readOnly = true)
+    public List<BuildingResponseDto> getAllBuildings() {
+        return buildingMapper.toResponseDtoList(buildingService.getAll());
+    }
+
+    private Building getBuildingOrThrow(final UUID id) {
+        return buildingService.getById(id)
+                              .orElseThrow(() -> new ResourceNotFoundException(
+                                  BUILDING_NOT_FOUND.getMessage(String.valueOf(id)))
+                              );
+    }
+
+    private University getUniversityOrThrow(final UUID universityId) {
+        return universityService.getById(universityId)
+                                .orElseThrow(() -> new ResourceNotFoundException(
+                                    UNIVERSITY_NOT_FOUND.getMessage(String.valueOf(universityId))));
+    }
+}

src/main/java/org/unilab/uniplan/building/dto/BuildingRequestDto.java

@@ -0,0 +1,17 @@
+package org.unilab.uniplan.building.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import java.util.UUID;
+
+public record BuildingRequestDto (
+    @NotBlank(message="Name is required")
+    @Size(max = 50)
+    String name,
+    @NotBlank(message="Address is required")
+    @Size(max = 50)
+    String address,
+    @NotNull(message = "University is required")
+    UUID universityId
+){}

src/main/java/org/unilab/uniplan/building/dto/BuildingResponseDto.java

@@ -0,0 +1,11 @@
+package org.unilab.uniplan.building.dto;
+
+import java.util.UUID;
+
+public record BuildingResponseDto (
+    UUID id,
+    String name,
+    String address,
+    UUID universityId,
+    String universityName
+){}

src/main/java/org/unilab/uniplan/category/Category.java

@@ -19,6 +19,10 @@ public class Category extends BaseEntity {
 
     @Column(name = "room_type", nullable = false, length = 50)
     private String roomType;
+
     @Column(name = "capacity", nullable = false)
     private short capacity;
+
+    @Column(name = "description", nullable = true, length = 100)
+    private String description;
 }

src/main/java/org/unilab/uniplan/university/University.java

@@ -2,12 +2,16 @@
 
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
+import jakarta.persistence.OneToMany;
 import jakarta.persistence.Table;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
+import org.unilab.uniplan.building.Building;
 import org.unilab.uniplan.common.model.BaseEntity;
+import java.util.ArrayList;
+import java.util.List;
 
 @Entity
 @Table(name = "university")
@@ -19,13 +23,19 @@ public class University extends BaseEntity {
 
     @Column(name = "uni_name", nullable = false)
     private String uniName;
+
     @Column(name = "location", length = 500)
     private String location;
+
     @Column(name = "established_year")
     private short establishedYear;
+
     @Column(name = "accreditation", length = 200)
     private String accreditation;
+
     @Column(name = "website", length = 2048)
     private String website;
 
+    @OneToMany(mappedBy="university")
+    private List<Building> buildings= new ArrayList<>();
 }

src/main/java/org/unilab/uniplan/utils/ErrorConstants.java

@@ -19,7 +19,8 @@ public enum ErrorConstants {
     STUDENT_GROUP_NOT_FOUND("Student group with ID {0} not found."),
     ROOM_CATEGORY_NOT_FOUND("Room category with ID {0} not found."),
     PROGRAM_DISCIPLINE_NOT_FOUND("Program discipline with ID {0} not found."),
-    PROGRAM_DISCIPLINE_LECTOR_NOT_FOUND("Program discipline lector with ID {0} not found.");
+    PROGRAM_DISCIPLINE_LECTOR_NOT_FOUND("Program discipline lector with ID {0} not found."),
+    BUILDING_NOT_FOUND("Building with ID {0} not found.");
 
     private final String message;