Done

src/main/java/com/example/task1/Dataloader/DataLoader.java

@@ -0,0 +1,144 @@
+package com.example.task1.Dataloader;
+
+import com.example.task1.Model.*;
+import com.example.task1.Service.*;
+import jdk.jfr.Event;
+import lombok.RequiredArgsConstructor;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+import java.util.Optional;
+
+@Component
+@RequiredArgsConstructor
+public class DataLoader implements CommandLineRunner {
+    private final SpeakerService speakerService;
+    private final GuestService guestService;
+    private final EventService eventService;
+    private final ExpositionService expositionService;
+    private final ConferenceService conferenceService;
+
+
+    @Override
+    public void run(String... args) throws Exception {
+        Event event = new Event();
+        event.setDuration(32);
+        event.setLocation("paris");
+        event.setTitle("mondial tattoo");
+        event.setDate(LocalDate.now());
+        eventService.save(event);
+
+        testCreateExposition();
+        testCreateExpositionWithGuest();
+        testDeleteGuestFromExposition();
+        testCreateConference();
+        testCreateConferenceWithSpeaker();
+        testDeletingSpeakerFromConference();
+        testCreatingConferenceWithGuest();
+        testDeletingGuestFromConference();
+    }
+
+    public void testCreateExposition() {
+        Exposition expositionSaved = createNewExposition();
+        Optional<Exposition> result = expositionService.findById(expositionSaved.getId().longValue());
+        if(result.isPresent()) {
+            System.out.println(result.get().getId() == expositionSaved.getId());
+        }
+    }
+
+    public void testCreateExpositionWithGuest() {
+        Guest guest = createNewGuest(createNewExposition());
+        Optional<Guest> result = guestService.findById(guest.getId().longValue());
+        if(result.isPresent()) {
+            System.out.println(result.get().getId() == guest.getId());
+        }
+    }
+
+    public void testDeleteGuestFromExposition() {
+        Guest guest = createNewGuest(createNewExposition());
+        guestService.deleteById(guest.getId());
+        Optional<Guest> result = guestService.findById(guest.getId().longValue());
+        if(result.isEmpty()) {
+            System.out.println("TEST deleting exposition guest : OK");
+        }
+    }
+
+    public void testCreateConference() {
+        Conference confSaved = createNewConference();
+        Optional<Conference> conferenceRetrieved = conferenceService.findById(confSaved.getId().longValue());
+        if(conferenceRetrieved.isPresent()) {
+            System.out.println(conferenceRetrieved.get().getId() == confSaved.getId());
+        }
+    }
+
+    public void testCreateConferenceWithSpeaker() {
+        Speaker speaker = createNewSpeaker(createNewConference());
+        Optional<Speaker> result = speakerService.findById(speaker.getId().longValue());
+        if(result.isPresent()) {
+            System.out.println(result.get().getId() == speaker.getId());
+        }
+    }
+
+    public void testDeletingSpeakerFromConference() {
+        Speaker speaker = createNewSpeaker(createNewConference());
+        speakerService.deleteById(speaker.getId());
+        Optional<Speaker> result = speakerService.findById(speaker.getId().longValue());
+        if(result.isEmpty()) {
+            System.out.println("TEST deleting speaker : OK");
+        }
+    }
+
+    public void testCreatingConferenceWithGuest() {
+        Guest guest = createNewGuest(createNewConference());
+        Optional<Guest> result = guestService.findById(guest.getId().longValue());
+        if(result.isPresent()) {
+            System.out.println(result.get().getId() == guest.getId());
+        }
+    }
+
+    public void testDeletingGuestFromConference() {
+        Guest guest = createNewGuest(createNewConference());
+        guestService.deleteById(guest.getId());
+        Optional<Guest> result = guestService.findById(guest.getId().longValue());
+        if(result.isEmpty()) {
+            System.out.println("TEST deleting conference guest : OK");
+        }
+    }
+
+    private Guest createNewGuest( Event event) {
+        Guest guest = new Guest();
+        guest.setName(faker.name().femaleFirstName());
+        guest.setStatus(GuestStatus.ATTENDING);
+        guest.setEvent(event);
+        return guestService.save(guest);
+    }
+
+    private Exposition createNewExposition() {
+        Exposition exposition = new Exposition();
+        exposition.setDuration(faker.number().positive());
+        exposition.setLocation(faker.address().city());
+        exposition.setTitle(faker.artist().name());
+        exposition.setDate(LocalDate.now());
+        return expositionService.save(exposition);
+    }
+
+    private Speaker createNewSpeaker(Conference confSaved) {
+        Speaker speaker = new Speaker();
+        speaker.setName(faker.name().fullName());
+        speaker.setPresentationDuration(faker.number().positive());
+        speaker.setConference(confSaved);
+        return speakerService.save(speaker);
+    }
+
+    private Conference createNewConference() {
+        Conference conference = new Conference();
+        conference.setDuration(faker.number().positive());
+        conference.setLocation(faker.address().city());
+        conference.setTitle(faker.community().character());
+        conference.setDate(LocalDate.now());
+        return conferenceService.save(conference);
+    }
+
+
+}

src/main/java/com/example/task1/Model/Conference.java

@@ -0,0 +1,27 @@
+package com.example.task1.Model;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.PrimaryKeyJoinColumn;
+import jdk.jfr.Event;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@Entity
+
+@PrimaryKeyJoinColumn(name="id")
+public class Conference extends Event {
+
+    @OneToMany(mappedBy = "id")
+    private List<Speaker> speakers = new ArrayList<>();
+
+    public Conference(String title, String description, LocalDate startDate, LocalDate endDate) {
+        super (title, location, date, duration)
+    }
+}

src/main/java/com/example/task1/Model/Event.java

@@ -0,0 +1,36 @@
+package com.example.task1.Model;
+
+import jakarta.persistence.*;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@Entity
+
+@Inheritance(strategy= InheritanceType.JOINED)
+public class Event {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private Long id;
+
+    private String title;
+    private String location;
+    private LocalDate date;
+    private Integer duration;
+
+    @OneToMany(mappedBy = "event")
+    private List<Guest> guests = new ArrayList<>();
+
+    public Event(String title, String location, LocalDate date, Integer duration) {
+        this.title = title;
+        this.location = location;
+        this.date = date;
+        this.duration = duration;
+    }
+}

src/main/java/com/example/task1/Model/Exposition.java

@@ -0,0 +1,17 @@
+package com.example.task1.Model;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.PrimaryKeyJoinColumn;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@Entity
+@PrimaryKeyJoinColumn(name="id")
+public class Exposition extends Event {
+
+    public Exposition(String title, String location, LocalDate date, Integer duration) {
+        super(title, location, date, duration);
+    }
+}

src/main/java/com/example/task1/Model/Guest.java

@@ -0,0 +1,30 @@
+package com.example.task1.Model;
+
+import jakarta.persistence.*;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@Entity
+public class Guest {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private Long id;
+
+    private String name;
+
+    @Enumerated(EnumType.STRING)
+    private GuestStatus status;
+
+    //we want a lazy loading by default eager
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "eventId", referencedColumnName = "id")
+    private Event event;
+
+    public Guest(String name, GuestStatus status) {
+        this.name = name;
+        this.status = status;
+    }
+}

src/main/java/com/example/task1/Model/GuestStatus.java

@@ -0,0 +1,5 @@
+package com.example.task1.Model;
+
+public enum GuestStatus {
+    ATTENDING, NOT_ATTENDING, NO_RESPONSE
+}

src/main/java/com/example/task1/Model/Speaker.java

@@ -0,0 +1,27 @@
+package com.example.task1.Model;
+
+import jakarta.persistence.*;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@Entity
+public class Speaker {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private Long id;
+    private String name;
+    private Integer presentationDuration;
+
+    //we want a lazy loading by default eager
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "conferenceId" , referencedColumnName = "id")
+    private Conference conference;
+
+    public Speaker(String name, Integer presentationDuration) {
+        this.name = name;
+        this.presentationDuration = presentationDuration;
+    }
+}

src/main/java/com/example/task1/Repositoty/ConferenceRepository.java

@@ -0,0 +1,7 @@
+package com.example.task1.Repositoty;
+
+import com.example.task1.Model.Conference;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ConferenceRepository extends JpaRepository<Conference, Long> {
+}

src/main/java/com/example/task1/Repositoty/EventRepository.java

@@ -0,0 +1,7 @@
+package com.example.task1.Repositoty;
+
+import jdk.jfr.Event;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface EventRepository extends JpaRepository<Event, Long> {
+}

src/main/java/com/example/task1/Repositoty/ExpositionRepository.java

@@ -0,0 +1,7 @@
+package com.example.task1.Repositoty;
+
+import com.example.task1.Model.Exposition;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ExpositionRepository extends JpaRepository<Exposition,Long> {
+}

src/main/java/com/example/task1/Repositoty/GuestRepository.java

@@ -0,0 +1,7 @@
+package com.example.task1.Repositoty;
+
+import com.example.task1.Model.Guest;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface GuestRepository extends JpaRepository<Guest, Long> {
+}

src/main/java/com/example/task1/Repositoty/SpeakerRepository.java

@@ -0,0 +1,7 @@
+package com.example.task1.Repositoty;
+
+import com.example.task1.Model.Speaker;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface SpeakerRepository extends JpaRepository<Speaker, Long> {
+}

src/main/java/com/example/task1/Service/ConferenceService.java

@@ -0,0 +1,28 @@
+package com.example.task1.Service;
+
+import com.example.task1.Model.Conference;
+import com.example.task1.Repositoty.ConferenceRepository;
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class ConferenceService {
+    private final ConferenceRepository conferenceRepository;
+
+    @Transactional
+    public Conference save(Conference conference) {
+        return conferenceRepository.save(conference);
+    }
+
+    public long count() {
+        return conferenceRepository.count();
+    }
+
+    public Optional<Conference> findById(long id) {
+        return conferenceRepository.findById(id);
+    }
+}

src/main/java/com/example/task1/Service/EventService.java

@@ -0,0 +1,22 @@
+package com.example.task1.Service;
+
+import com.example.task1.Repositoty.EventRepository;
+import jakarta.transaction.Transactional;
+import jdk.jfr.Event;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class EventService {
+    private final EventRepository eventRepository;
+
+    @Transactional
+    public Event save(Event event) {
+        return eventRepository.save(event);
+    }
+
+    public long count() {
+        return eventRepository.count();
+    }
+}