worker = new SwingWorker<>() {
+ @Override
+ protected Void doInBackground() {
+ controller.display(userLocation, DEFAULT_RADIUS_KM, category);
+ return null;
+ }
+
+ @Override
+ protected void done() {
+ searchEventsButton.setText("Search Events");
+ searchEventsButton.setEnabled(true);
+ }
+ };
+ worker.execute();
+ }
+
+ private void renderEmptyState() {
+ cardsContainer.removeAll();
+ cardsContainer.setLayout(new GridBagLayout());
+ cardsContainer.setBackground(new Color(245, 247, 250));
+
+ JPanel emptyPanel = new JPanel();
+ emptyPanel.setLayout(new BoxLayout(emptyPanel, BoxLayout.Y_AXIS));
+ emptyPanel.setBackground(new Color(245, 247, 250));
+ emptyPanel.setBorder(new EmptyBorder(30, 50, 30, 50));
+
+ // Icon
+ JLabel iconLabel = new JLabel("*", SwingConstants.CENTER);
+ iconLabel.setFont(new Font("Segoe UI", Font.BOLD, 48));
+ iconLabel.setForeground(new Color(100, 100, 100));
+ iconLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ // Title
+ JLabel titleLabel = new JLabel("Find Events Near You");
+ titleLabel.setFont(new Font("Segoe UI", Font.BOLD, 24));
+ titleLabel.setForeground(new Color(50, 50, 50));
+ titleLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ // Description
+ String message = selectedDate != null
+ ? "No events found for the selected date.
Try a different date or clear the filter.
"
+ : "Enter your location above and click
'Search Events' to discover local events!
";
+ JLabel descLabel = new JLabel(message);
+ descLabel.setFont(new Font("Segoe UI", Font.PLAIN, 14));
+ descLabel.setForeground(new Color(120, 120, 120));
+ descLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+ descLabel.setHorizontalAlignment(SwingConstants.CENTER);
+
+ emptyPanel.add(iconLabel);
+ emptyPanel.add(Box.createVerticalStrut(20));
+ emptyPanel.add(titleLabel);
+ emptyPanel.add(Box.createVerticalStrut(12));
+ emptyPanel.add(descLabel);
+
+ GridBagConstraints gbc = new GridBagConstraints();
+ gbc.gridx = 0;
+ gbc.gridy = 0;
+ gbc.weightx = 1.0;
+ gbc.weighty = 1.0;
+ gbc.anchor = GridBagConstraints.CENTER;
+
+ cardsContainer.add(emptyPanel, gbc);
+ cardsContainer.revalidate();
+ cardsContainer.repaint();
+ }
+
+ public void renderEvents() {
+ cardsContainer.removeAll();
+
+ if (viewModel.hasError()) {
+ cardsContainer.setLayout(new BorderLayout());
+ JLabel errorLabel = new JLabel("Error: " + viewModel.getError(), SwingConstants.CENTER);
+ errorLabel.setForeground(new Color(211, 47, 47));
+ errorLabel.setFont(errorLabel.getFont().deriveFont(Font.BOLD, 13f));
+ cardsContainer.add(errorLabel, BorderLayout.CENTER);
+ } else if (!viewModel.hasEvents()) {
+ renderEmptyState();
+ return;
+ } else {
+ List cards = new ArrayList<>(viewModel.getEventCards());
+
+ // Apply date filter if set
+ if (selectedDate != null) {
+ cards = cards.stream()
+ .filter(card -> {
+ String dateTimeStr = card.getDateTime();
+ if (dateTimeStr != null && dateTimeStr.length() >= 10) {
+ try {
+ LocalDate cardDate = LocalDate.parse(dateTimeStr.substring(0, 10));
+ return cardDate.equals(selectedDate);
+ } catch (Exception e) {
+ return true;
+ }
+ }
+ return true;
+ })
+ .collect(Collectors.toList());
+ }
+
+ if (cards.isEmpty()) {
+ renderEmptyState();
+ return;
+ }
+
+ String sortBy = (String) sortBox.getSelectedItem();
+
+ if ("Name".equalsIgnoreCase(sortBy)) {
+ cards.sort(Comparator.comparing(
+ DisplayLocalEventsViewModel.EventCard::getName,
+ String.CASE_INSENSITIVE_ORDER));
+ } else if ("Date".equalsIgnoreCase(sortBy)) {
+ cards.sort(Comparator.comparing(
+ DisplayLocalEventsViewModel.EventCard::getDateTime));
+ } else {
+ cards.sort(Comparator.comparingDouble(this::parseDistance));
+ }
+
+ cardsContainer.setLayout(new GridLayout(0, 2, 12, 12));
+ for (DisplayLocalEventsViewModel.EventCard cardData : cards) {
+ JPanel card = buildEventCard(cardData);
+ cardsContainer.add(card);
+ }
+ }
+
+ cardsContainer.revalidate();
+ cardsContainer.repaint();
+ }
+
+ private double parseDistance(DisplayLocalEventsViewModel.EventCard card) {
+ String text = card.getDistanceText();
+ if (text == null || text.isBlank()) {
+ return Double.MAX_VALUE;
+ }
+ try {
+ String firstToken = text.split("\\s+")[0];
+ return Double.parseDouble(firstToken);
+ } catch (Exception e) {
+ return Double.MAX_VALUE;
+ }
+ }
+
+ private JPanel buildEventCard(DisplayLocalEventsViewModel.EventCard cardData) {
+ JPanel card = new JPanel(new BorderLayout());
+ card.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createEmptyBorder(4, 4, 4, 4),
+ BorderFactory.createLineBorder(new Color(230, 230, 230), 1)
+ ));
+ card.setBackground(Color.WHITE);
+ card.setCursor(new Cursor(Cursor.HAND_CURSOR));
+
+ card.addMouseListener(new java.awt.event.MouseAdapter() {
+ @Override
+ public void mouseClicked(java.awt.event.MouseEvent e) {
+ onEventCardClicked(cardData.getId());
+ }
+
+ @Override
+ public void mouseEntered(java.awt.event.MouseEvent e) {
+ card.setBackground(new Color(248, 250, 252));
+ card.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createEmptyBorder(4, 4, 4, 4),
+ BorderFactory.createLineBorder(new Color(25, 118, 210), 2)
+ ));
+ }
+
+ @Override
+ public void mouseExited(java.awt.event.MouseEvent e) {
+ card.setBackground(Color.WHITE);
+ card.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createEmptyBorder(4, 4, 4, 4),
+ BorderFactory.createLineBorder(new Color(230, 230, 230), 1)
+ ));
+ }
+ });
+
+ JLabel pictureLabel = new JLabel("", SwingConstants.CENTER);
+ pictureLabel.setPreferredSize(new Dimension(200, 120));
+ pictureLabel.setBackground(new Color(240, 240, 240));
+ pictureLabel.setOpaque(true);
+ ImageIcon icon = loadImageIcon(cardData.getImageUrl(), 200, 120);
+ if (icon != null) {
+ pictureLabel.setIcon(icon);
+ } else {
+ pictureLabel.setText("[No Image]");
+ pictureLabel.setFont(new Font("Segoe UI", Font.PLAIN, 14));
+ pictureLabel.setForeground(new Color(180, 180, 180));
+ }
+ card.add(pictureLabel, BorderLayout.NORTH);
+
+ JPanel textPanel = new JPanel();
+ textPanel.setLayout(new BoxLayout(textPanel, BoxLayout.Y_AXIS));
+ textPanel.setBorder(new EmptyBorder(10, 12, 10, 12));
+ textPanel.setOpaque(false);
+
+ String truncatedName = truncateText(cardData.getName(), 40);
+ JLabel nameLabel = new JLabel("" + truncatedName + "");
+ nameLabel.setFont(new Font("Segoe UI", Font.PLAIN, 14));
+
+ String truncatedAddress = truncateText(cardData.getAddress(), 50);
+ JLabel addressLabel = new JLabel(truncatedAddress);
+ addressLabel.setFont(new Font("Segoe UI", Font.PLAIN, 11));
+ addressLabel.setForeground(new Color(100, 100, 100));
+
+ JLabel dateLabel = new JLabel(cardData.getDateTime());
+ dateLabel.setFont(new Font("Segoe UI", Font.PLAIN, 11));
+ dateLabel.setForeground(new Color(120, 120, 120));
+
+ JLabel distanceLabel = new JLabel(cardData.getDistanceText() + " away");
+ distanceLabel.setFont(new Font("Segoe UI", Font.BOLD, 12));
+ distanceLabel.setForeground(new Color(25, 118, 210));
+
+ textPanel.add(nameLabel);
+ textPanel.add(Box.createVerticalStrut(4));
+ textPanel.add(addressLabel);
+ textPanel.add(Box.createVerticalStrut(4));
+ textPanel.add(dateLabel);
+ textPanel.add(Box.createVerticalStrut(6));
+ textPanel.add(distanceLabel);
+
+ card.add(textPanel, BorderLayout.CENTER);
+ return card;
+ }
+
+ /**
+ * Truncate text to a maximum length, adding "..." if truncated.
+ */
+ private String truncateText(String text, int maxLength) {
+ if (text == null) return "";
+ if (text.length() <= maxLength) return text;
+ return text.substring(0, maxLength - 3) + "...";
+ }
+
+ private void onEventCardClicked(String eventId) {
+ List events = viewModel.getEvents();
+
+ Event selectedEvent = null;
+ if (events != null) {
+ for (Event event : events) {
+ if (event.getId().equals(eventId)) {
+ selectedEvent = event;
+ break;
+ }
+ }
+ }
+
+ if (selectedEvent != null && eventSelectionListener != null) {
+ eventSelectionListener.onEventSelected(selectedEvent);
+ }
+ }
+
+ private ImageIcon loadImageIcon(String imageUrl, int width, int height) {
+ if (imageUrl == null || imageUrl.isBlank()) {
+ return null;
+ }
+ try {
+ BufferedImage img = ImageIO.read(new URL(imageUrl));
+ if (img == null) {
+ return null;
+ }
+ Image scaled = img.getScaledInstance(width, height, Image.SCALE_SMOOTH);
+ return new ImageIcon(scaled);
+ } catch (IOException e) {
+ return null;
+ }
+ }
+
+ public void setSearchBarController(SearchController controller) {
+ if (searchBarView != null) {
+ this.searchBarView.setSearchController(controller);
+ }
+ }
+
+ private void navigateToCalendar() {
+ // Use the user's saved/entered location, or default to Toronto
+ Location userLoc = userLocation;
+ if (userLoc == null) {
+ userLoc = new Location("Toronto, ON", 43.6532, -79.3832);
+ }
+
+ if (calendarView != null) {
+ calendarView.setUserLocation(userLoc);
+ calendarView.setSearchRadiusKm(DEFAULT_RADIUS_KM);
+ }
+
+ if (viewManagerModel != null) {
+ viewManagerModel.setState(ViewNames.CALENDAR);
+ viewManagerModel.firePropertyChange();
+ }
+ }
+
+ private void navigateToSavedEvents() {
+ if (viewManagerModel != null) {
+ viewManagerModel.setState(ViewNames.SAVE_EVENTS);
+ viewManagerModel.firePropertyChange();
+ }
+ }
+
+ private void handleLogout() {
+ userLocation = null;
+ locationLoaded = false;
+ selectedDate = null;
+ updateDateFilterDisplay();
+ if (currentLocationLabel != null) {
+ currentLocationLabel.setText("No location set");
+ currentLocationLabel.setForeground(new Color(255, 200, 200));
+ }
+ if (viewManagerModel != null) {
+ viewManagerModel.setState(ViewNames.LOGIN);
+ viewManagerModel.firePropertyChange();
+ }
+ }
+
+ public DisplayLocalEventsViewModel getViewModel() {
+ return this.viewModel;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/view/EventDescriptionView.java b/src/main/java/view/EventDescriptionView.java
new file mode 100644
index 00000000..d6c24da9
--- /dev/null
+++ b/src/main/java/view/EventDescriptionView.java
@@ -0,0 +1,441 @@
+package view;
+
+import entity.Event;
+import entity.Location;
+import interface_adapter.ViewManagerModel;
+import interface_adapter.ViewNames;
+import interface_adapter.event_description.EventDescriptionViewModel;
+import interface_adapter.save_event.SaveEventController;
+import use_case.save_event.SaveEventInteractor;
+
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.io.IOException;
+import java.net.URL;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * View for displaying event details.
+ *
+ * Features:
+ * - Shows event details (name, category, date, location, description)
+ * - Displays event image
+ * - Shows distance from user's location
+ * - Save Event button that shows "Already Saved" if event is already saved
+ * - Back navigation to previous view (events list or calendar event list)
+ */
+public class EventDescriptionView extends JPanel implements PropertyChangeListener {
+
+ private final EventDescriptionViewModel viewModel;
+ private ViewManagerModel viewManagerModel;
+ private SaveEventController saveEventController;
+ private SaveEventInteractor saveEventInteractor;
+ private Event currentEvent;
+
+ // Track which view we came from for back navigation
+ private String previousViewName = ViewNames.DISPLAY_LOCAL_EVENTS;
+
+ // UI Components
+ private final JLabel titleLabel = new JLabel("", SwingConstants.LEFT);
+ private final JLabel categoryLabel = new JLabel();
+ private final JLabel dateTimeLabel = new JLabel();
+ private final JLabel addressLabel = new JLabel();
+ private final JTextArea descriptionArea = new JTextArea();
+ private final JLabel distanceLabel = new JLabel();
+ private final JLabel imageLabel = new JLabel();
+ private final JButton backButton = new JButton("<- Back");
+ private final JButton saveButton = new JButton("Save Event");
+
+ private final DateTimeFormatter displayFormatter = DateTimeFormatter.ofPattern("EEEE, MMMM d, yyyy 'at' h:mm a");
+
+ public EventDescriptionView(EventDescriptionViewModel viewModel) {
+ this.viewModel = viewModel;
+ this.viewModel.addPropertyChangeListener(this);
+
+ initializeUI();
+ }
+
+ private void initializeUI() {
+ setLayout(new BorderLayout());
+ setBackground(Color.WHITE);
+
+ // Header with back button
+ JPanel headerPanel = createHeaderPanel();
+ add(headerPanel, BorderLayout.NORTH);
+
+ // Main content - split into image and details
+ JSplitPane mainContent = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
+ mainContent.setDividerLocation(500);
+ mainContent.setDividerSize(0);
+ mainContent.setBorder(null);
+
+ // Left side - Image
+ JPanel imagePanel = createImagePanel();
+ mainContent.setLeftComponent(imagePanel);
+
+ // Right side - Details
+ JPanel detailsPanel = createDetailsPanel();
+ JScrollPane detailsScroll = new JScrollPane(detailsPanel);
+ detailsScroll.setBorder(null);
+ detailsScroll.getVerticalScrollBar().setUnitIncrement(16);
+ mainContent.setRightComponent(detailsScroll);
+
+ add(mainContent, BorderLayout.CENTER);
+ }
+
+ private JPanel createHeaderPanel() {
+ JPanel header = new JPanel(new BorderLayout());
+ header.setBackground(new Color(25, 118, 210));
+ header.setBorder(new EmptyBorder(15, 20, 15, 20));
+
+ // Style back button
+ backButton.setFont(new Font("Segoe UI", Font.PLAIN, 14));
+ backButton.setForeground(Color.WHITE);
+ backButton.setBackground(new Color(25, 118, 210));
+ backButton.setBorder(BorderFactory.createEmptyBorder(8, 15, 8, 15));
+ backButton.setFocusPainted(false);
+ backButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
+ backButton.setOpaque(true);
+
+ backButton.addMouseListener(new java.awt.event.MouseAdapter() {
+ @Override
+ public void mouseEntered(java.awt.event.MouseEvent e) {
+ backButton.setBackground(new Color(21, 101, 192));
+ }
+
+ @Override
+ public void mouseExited(java.awt.event.MouseEvent e) {
+ backButton.setBackground(new Color(25, 118, 210));
+ }
+ });
+
+ backButton.addActionListener(e -> navigateBack());
+
+ header.add(backButton, BorderLayout.WEST);
+
+ JLabel headerTitle = new JLabel("Event Details");
+ headerTitle.setFont(new Font("Segoe UI", Font.BOLD, 20));
+ headerTitle.setForeground(Color.WHITE);
+ headerTitle.setHorizontalAlignment(SwingConstants.CENTER);
+ header.add(headerTitle, BorderLayout.CENTER);
+
+ return header;
+ }
+
+ private JPanel createImagePanel() {
+ JPanel panel = new JPanel(new BorderLayout());
+ panel.setBackground(new Color(30, 30, 30));
+ panel.setPreferredSize(new Dimension(500, 600));
+
+ imageLabel.setHorizontalAlignment(SwingConstants.CENTER);
+ imageLabel.setVerticalAlignment(SwingConstants.CENTER);
+ imageLabel.setForeground(Color.WHITE);
+ imageLabel.setText("Loading image...");
+
+ panel.add(imageLabel, BorderLayout.CENTER);
+ return panel;
+ }
+
+ private JPanel createDetailsPanel() {
+ JPanel panel = new JPanel();
+ panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
+ panel.setBackground(Color.WHITE);
+ panel.setBorder(new EmptyBorder(30, 30, 30, 30));
+
+ // Category badge
+ categoryLabel.setFont(new Font("Segoe UI", Font.BOLD, 12));
+ categoryLabel.setForeground(new Color(59, 130, 246));
+ categoryLabel.setOpaque(true);
+ categoryLabel.setBackground(new Color(219, 234, 254));
+ categoryLabel.setBorder(new EmptyBorder(5, 12, 5, 12));
+ categoryLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+ panel.add(categoryLabel);
+ panel.add(Box.createVerticalStrut(15));
+
+ // Title
+ titleLabel.setFont(new Font("Segoe UI", Font.BOLD, 28));
+ titleLabel.setForeground(new Color(17, 24, 39));
+ titleLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+ panel.add(titleLabel);
+ panel.add(Box.createVerticalStrut(20));
+
+ // Date/Time section
+ panel.add(createInfoRow("Date & Time", dateTimeLabel));
+ panel.add(Box.createVerticalStrut(15));
+
+ // Location section
+ panel.add(createInfoRow("Location", addressLabel));
+ panel.add(Box.createVerticalStrut(15));
+
+ // Distance section
+ panel.add(createInfoRow("Distance", distanceLabel));
+ panel.add(Box.createVerticalStrut(25));
+
+ // Description section
+ JLabel descTitle = new JLabel("About This Event");
+ descTitle.setFont(new Font("Segoe UI", Font.BOLD, 18));
+ descTitle.setForeground(new Color(17, 24, 39));
+ descTitle.setAlignmentX(Component.LEFT_ALIGNMENT);
+ panel.add(descTitle);
+ panel.add(Box.createVerticalStrut(10));
+
+ descriptionArea.setFont(new Font("Segoe UI", Font.PLAIN, 14));
+ descriptionArea.setForeground(new Color(75, 85, 99));
+ descriptionArea.setBackground(Color.WHITE);
+ descriptionArea.setLineWrap(true);
+ descriptionArea.setWrapStyleWord(true);
+ descriptionArea.setEditable(false);
+ descriptionArea.setBorder(null);
+ descriptionArea.setAlignmentX(Component.LEFT_ALIGNMENT);
+ descriptionArea.setMaximumSize(new Dimension(400, 200));
+ panel.add(descriptionArea);
+ panel.add(Box.createVerticalStrut(30));
+
+ // Save button
+ styleSaveButton();
+ saveButton.setAlignmentX(Component.LEFT_ALIGNMENT);
+ saveButton.addActionListener(e -> saveEvent());
+ panel.add(saveButton);
+
+ return panel;
+ }
+
+ private JPanel createInfoRow(String label, JLabel valueLabel) {
+ JPanel row = new JPanel();
+ row.setLayout(new BoxLayout(row, BoxLayout.Y_AXIS));
+ row.setOpaque(false);
+ row.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ JLabel titleLbl = new JLabel(label);
+ titleLbl.setFont(new Font("Segoe UI", Font.BOLD, 14));
+ titleLbl.setForeground(new Color(107, 114, 128));
+ titleLbl.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ valueLabel.setFont(new Font("Segoe UI", Font.PLAIN, 16));
+ valueLabel.setForeground(new Color(17, 24, 39));
+ valueLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ row.add(titleLbl);
+ row.add(Box.createVerticalStrut(5));
+ row.add(valueLabel);
+
+ return row;
+ }
+
+ private void styleSaveButton() {
+ saveButton.setFont(new Font("Segoe UI", Font.BOLD, 14));
+ saveButton.setForeground(Color.WHITE);
+ saveButton.setBackground(new Color(59, 130, 246));
+ saveButton.setBorder(new EmptyBorder(12, 30, 12, 30));
+ saveButton.setFocusPainted(false);
+ saveButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
+ saveButton.setOpaque(true);
+
+ saveButton.addMouseListener(new java.awt.event.MouseAdapter() {
+ @Override
+ public void mouseEntered(java.awt.event.MouseEvent e) {
+ if (saveButton.isEnabled()) {
+ saveButton.setBackground(new Color(37, 99, 235));
+ }
+ }
+
+ @Override
+ public void mouseExited(java.awt.event.MouseEvent e) {
+ if (saveButton.isEnabled()) {
+ saveButton.setBackground(new Color(59, 130, 246));
+ }
+ }
+ });
+ }
+
+ /**
+ * Set the previous view name for back navigation.
+ * Called before navigating to this view.
+ */
+ public void setPreviousView(String viewName) {
+ this.previousViewName = viewName;
+ }
+
+ /**
+ * Display an event's details.
+ * This method is called when navigating to this view with an event.
+ */
+ public void displayEvent(Event event) {
+ this.currentEvent = event;
+
+ if (event == null) {
+ titleLabel.setText("Event Not Found");
+ categoryLabel.setText("N/A");
+ dateTimeLabel.setText("N/A");
+ addressLabel.setText("N/A");
+ distanceLabel.setText("N/A");
+ descriptionArea.setText("The requested event could not be found.");
+ resetSaveButton();
+ return;
+ }
+
+ // Update all fields
+ titleLabel.setText("" + event.getName() + "");
+ categoryLabel.setText(event.getCategory().getDisplayName());
+ dateTimeLabel.setText(event.getStartTime().format(displayFormatter));
+ addressLabel.setText("" + event.getLocation().getAddress() + "");
+
+ // Description
+ String desc = event.getDescription();
+ if (desc == null || desc.trim().isEmpty()) {
+ descriptionArea.setText("No description available for this event.");
+ } else {
+ descriptionArea.setText(desc);
+ }
+
+ // Load image
+ loadEventImage(event.getImageUrl());
+
+ // Distance will be set separately via setDistanceText
+ distanceLabel.setText("Calculating...");
+
+ // Check if event is already saved and update button accordingly
+ updateSaveButtonState();
+ }
+
+ /**
+ * Check if the current event is already saved and update button state.
+ */
+ private void updateSaveButtonState() {
+ if (currentEvent != null && saveEventInteractor != null) {
+ boolean isAlreadySaved = saveEventInteractor.isEventSaved(currentEvent.getId());
+ if (isAlreadySaved) {
+ showAlreadySavedState();
+ } else {
+ resetSaveButton();
+ }
+ } else {
+ resetSaveButton();
+ }
+ }
+
+ /**
+ * Show the button in "Already Saved" state.
+ */
+ private void showAlreadySavedState() {
+ saveButton.setText("Saved");
+ saveButton.setBackground(new Color(34, 197, 94));
+ saveButton.setEnabled(false);
+ saveButton.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
+ }
+
+ /**
+ * Reset save button to default state.
+ */
+ private void resetSaveButton() {
+ saveButton.setText("Save Event");
+ saveButton.setBackground(new Color(59, 130, 246));
+ saveButton.setEnabled(true);
+ saveButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
+ }
+
+ /**
+ * Set the distance text (called after distance calculation).
+ */
+ public void setDistanceText(String distanceText) {
+ distanceLabel.setText(distanceText);
+ }
+
+ private void loadEventImage(String imageUrl) {
+ if (imageUrl == null || imageUrl.trim().isEmpty()) {
+ imageLabel.setIcon(null);
+ imageLabel.setText("No image available");
+ return;
+ }
+
+ // Load image in background thread to avoid UI freeze
+ new SwingWorker() {
+ @Override
+ protected ImageIcon doInBackground() {
+ try {
+ BufferedImage img = ImageIO.read(new URL(imageUrl));
+ if (img != null) {
+ Image scaled = img.getScaledInstance(480, 400, Image.SCALE_SMOOTH);
+ return new ImageIcon(scaled);
+ }
+ } catch (IOException e) {
+ System.err.println("Failed to load event image: " + e.getMessage());
+ }
+ return null;
+ }
+
+ @Override
+ protected void done() {
+ try {
+ ImageIcon icon = get();
+ if (icon != null) {
+ imageLabel.setIcon(icon);
+ imageLabel.setText("");
+ } else {
+ imageLabel.setIcon(null);
+ imageLabel.setText("Failed to load image");
+ }
+ } catch (Exception e) {
+ imageLabel.setText("Error loading image");
+ }
+ }
+ }.execute();
+ }
+
+ /**
+ * Navigate back to the previous view.
+ * This respects which view the user came from.
+ */
+ private void navigateBack() {
+ if (viewManagerModel != null) {
+ viewManagerModel.setState(previousViewName);
+ viewManagerModel.firePropertyChange();
+ }
+ }
+
+ private void saveEvent() {
+ if (currentEvent != null && saveEventController != null) {
+ saveEventController.saveEvent(currentEvent);
+ showAlreadySavedState();
+
+ JOptionPane.showMessageDialog(this,
+ "Event saved! You can view it in your Saved Events.",
+ "Event Saved", JOptionPane.INFORMATION_MESSAGE);
+ } else {
+ JOptionPane.showMessageDialog(this,
+ "Unable to save event. Please try again.",
+ "Error", JOptionPane.ERROR_MESSAGE);
+ }
+ }
+
+ // Setters for dependency injection
+ public void setViewManagerModel(ViewManagerModel viewManagerModel) {
+ this.viewManagerModel = viewManagerModel;
+ }
+
+ public void setSaveEventController(SaveEventController saveEventController) {
+ this.saveEventController = saveEventController;
+ }
+
+ public void setSaveEventInteractor(SaveEventInteractor saveEventInteractor) {
+ this.saveEventInteractor = saveEventInteractor;
+ }
+
+ @Override
+ public void propertyChange(PropertyChangeEvent evt) {
+ if (viewModel.getErrorMessage() != null && !viewModel.getErrorMessage().isEmpty()) {
+ JOptionPane.showMessageDialog(this,
+ viewModel.getErrorMessage(),
+ "Error", JOptionPane.ERROR_MESSAGE);
+ }
+ }
+
+ public String getViewName() {
+ return EventDescriptionViewModel.VIEW_NAME;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/view/EventListByDateView.java b/src/main/java/view/EventListByDateView.java
new file mode 100644
index 00000000..42d166f1
--- /dev/null
+++ b/src/main/java/view/EventListByDateView.java
@@ -0,0 +1,339 @@
+package view;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.Locale;
+
+import javax.swing.BorderFactory;
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.SwingConstants;
+import javax.swing.border.EmptyBorder;
+
+import org.jetbrains.annotations.NotNull;
+
+import entity.Event;
+import interface_adapter.ViewManagerModel;
+import interface_adapter.ViewNames;
+import interface_adapter.calendarFlow.CalendarFlowController;
+import interface_adapter.calendarFlow.CalendarFlowState;
+import interface_adapter.calendarFlow.CalendarFlowViewModel;
+
+/**
+ * View for displaying a list of events occurring on a specific date.
+ * This view shows events retrieved from the calendar in a scrollable list format,
+ * with each event displayed as a card showing its name, location, and time.
+ * Users can click on individual events to view more details.
+ */
+public class EventListByDateView extends JPanel implements PropertyChangeListener {
+ private final String viewName = ViewNames.EVENT_LIST_BY_DATE;
+ private CalendarFlowViewModel calendarFlowViewModel;
+ private CalendarFlowController calendarFlowController;
+ private ViewManagerModel viewManagerModel;
+ private EventSelectionListener eventSelectionListener;
+
+ private final JLabel titleLabel = new JLabel("Events", SwingConstants.CENTER);
+ private final JLabel dateLabel = new JLabel("", SwingConstants.CENTER);
+ private final JPanel eventsContainer = new JPanel();
+ private final JScrollPane scrollPane;
+ private final JLabel emptyStateLabel = new JLabel("No events found for this date.", SwingConstants.CENTER);
+ private final JButton backButton = new JButton("<- Back to DashBoard");
+ private final String textFont = "Segoe UI";
+
+ public EventListByDateView(CalendarFlowViewModel calendarFlowViewModel) {
+ this.calendarFlowViewModel = calendarFlowViewModel;
+ this.calendarFlowViewModel.addPropertyChangeListener(this);
+
+ setLayout(new BorderLayout());
+ setBorder(new EmptyBorder(
+ Constants.EMPTY_BORDER_SIZE,
+ Constants.EMPTY_BORDER_SIZE,
+ Constants.EMPTY_BORDER_SIZE,
+ Constants.EMPTY_BORDER_SIZE));
+ setBackground(new Color(Constants.BACKGROUND_COLOR_R,
+ Constants.BACKGROUND_COLOR_G,
+ Constants.BACKGROUND_COLOR_B));
+
+ add(buildTopPanel(), BorderLayout.NORTH);
+
+ eventsContainer.setLayout(new BoxLayout(eventsContainer, BoxLayout.Y_AXIS));
+ eventsContainer.setBorder(new EmptyBorder(Constants.CONTAINER_EMPTY_BORDER_SIZE,
+ Constants.CONTAINER_EMPTY_BORDER_SIZE,
+ Constants.CONTAINER_EMPTY_BORDER_SIZE,
+ Constants.CONTAINER_EMPTY_BORDER_SIZE));
+ eventsContainer.setBackground(new Color(Constants.BACKGROUND_COLOR_R,
+ Constants.BACKGROUND_COLOR_G,
+ Constants.BACKGROUND_COLOR_B));
+
+ scrollPane = new JScrollPane(eventsContainer);
+ scrollPane.getVerticalScrollBar().setUnitIncrement(Constants.UNIT_INCREMENT_SCALE);
+ scrollPane.setBorder(null);
+ add(scrollPane, BorderLayout.CENTER);
+ }
+
+ public void setController(CalendarFlowController controller) {
+ this.calendarFlowController = controller;
+ }
+
+ public void setViewManagerModel(ViewManagerModel viewManagerModel) {
+ this.viewManagerModel = viewManagerModel;
+ }
+
+ public void setEventSelectionListener(EventSelectionListener listener) {
+ this.eventSelectionListener = listener;
+ }
+
+ private JPanel buildTopPanel() {
+ final JPanel topPanel = new JPanel(new BorderLayout());
+ topPanel.setBorder(new EmptyBorder(Constants.TOP_PANEL_EMPTY_BORDER_SIZE,
+ Constants.TOP_PANEL_EMPTY_BORDER_SIZE,
+ Constants.TOP_PANEL_EMPTY_BORDER_SIZE,
+ Constants.TOP_PANEL_EMPTY_BORDER_SIZE));
+ topPanel.setBackground(new Color(Constants.TOP_PANEL_BACKGROUND_COLOR_R,
+ Constants.TOP_PANEL_BACKGROUND_COLOR_G,
+ Constants.TOP_PANEL_BACKGROUND_COLOR_B));
+
+ backButton.setFocusPainted(false);
+ backButton.setBackground(Color.WHITE);
+ backButton.setForeground(Color.BLACK);
+ backButton.setContentAreaFilled(true);
+ backButton.setBorderPainted(true);
+ backButton.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createLineBorder(new Color(Constants.BACK_BUTTON_LINE_BOARDER_COLOR_R,
+ Constants.BACK_BUTTON_LINE_BOARDER_COLOR_G,
+ Constants.BACK_BUTTON_LINE_BOARDER_COLOR_B), 1),
+ new EmptyBorder(Constants.BACK_BUTTON_EMPTY_BOARDER_TOP,
+ Constants.BACK_BUTTON_EMPTY_BOARDER_LEFT,
+ Constants.BACK_BUTTON_EMPTY_BOARDER_BOTTOM,
+ Constants.BACK_BUTTON_EMPTY_BOARDER_RIGHT)
+ )
+ );
+ backButton.setFont(new Font(textFont, Font.PLAIN, Constants.BACK_BUTTON_FONT_SIZE));
+ backButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
+ backButton.setUI(new javax.swing.plaf.basic.BasicButtonUI());
+
+ backButton.addActionListener(event -> {
+ if (calendarFlowController != null) {
+ calendarFlowController.switchToDashboardView();
+ }
+ });
+
+ topPanel.add(backButton, BorderLayout.WEST);
+
+ final JPanel centerPanel = new JPanel();
+ centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.Y_AXIS));
+ centerPanel.setOpaque(false);
+
+ titleLabel.setFont(new Font(textFont, Font.BOLD, Constants.CENTER_PANEL_TITLE_LABEL_FONT_SIZE));
+ titleLabel.setForeground(Color.WHITE);
+ titleLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ dateLabel.setFont(new Font(textFont, Font.PLAIN, Constants.CENTER_PANEL_DATE_LABEL_FONT_SIZE));
+ dateLabel.setForeground(Color.WHITE);
+ dateLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ centerPanel.add(titleLabel);
+ centerPanel.add(Box.createVerticalStrut(Constants.CENTER_PANEL_BOX_VERTICAL_STRUC_HIGH));
+ centerPanel.add(dateLabel);
+ topPanel.add(centerPanel, BorderLayout.CENTER);
+
+ return topPanel;
+ }
+
+ @Override
+ public void propertyChange(PropertyChangeEvent evt) {
+ final CalendarFlowState state = (CalendarFlowState) evt.getNewValue();
+
+ if (state.getDate() != null) {
+ final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("EEEE, MMMM d, yyyy", Locale.ENGLISH);
+ dateLabel.setText(state.getDate().format(formatter));
+ }
+
+ if (state.getEventList() != null && !state.getEventList().isEmpty()) {
+ eventListsUi(state.getEventList());
+ }
+ else if (state.getErrorMessage() != null) {
+ renderError(state.getErrorMessage());
+ }
+ }
+
+ private void renderError(String errorMessage) {
+ eventsContainer.removeAll();
+ eventsContainer.setLayout(new BorderLayout());
+
+ final JLabel errorLabel = new JLabel(errorMessage, SwingConstants.CENTER);
+ errorLabel.setFont(errorLabel.getFont().deriveFont(Font.PLAIN, Constants.ERROR_LABEL_TEXT_FONT_SIZE));
+ errorLabel.setForeground(new Color(Constants.ERROR_LABEL_BACKGROUND_COLOR_R,
+ Constants.ERROR_LABEL_BACKGROUND_COLOR_G,
+ Constants.ERROR_LABEL_BACKGROUND_COLOR_B));
+
+ eventsContainer.add(errorLabel, BorderLayout.CENTER);
+ eventsContainer.revalidate();
+ eventsContainer.repaint();
+ }
+
+ private void eventListsUi(List events) {
+ eventsContainer.removeAll();
+ eventsContainer.setLayout(new BoxLayout(eventsContainer, BoxLayout.Y_AXIS));
+
+ for (Event event : events) {
+ final JPanel eventCard = buildEventCard(event);
+ eventsContainer.add(eventCard);
+ eventsContainer.add(Box.createVerticalStrut(Constants.EVENT_CONTAINER_BOX_VERTICAL_STRUC_HEIGHT));
+ }
+
+ eventsContainer.revalidate();
+ eventsContainer.repaint();
+ }
+
+ private JPanel buildEventCard(Event event) {
+ final JPanel card = createCardBasePanel();
+ final JPanel infoPanel = createInfoPanel();
+ final JLabel nameLabel = createNameLabel(event);
+ final JLabel locationLabel = createLocationLabel(event);
+
+ final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("h:mm a", Locale.ENGLISH);
+ final String timeText = event.getStartTime().format(timeFormatter);
+ final JLabel timeLabel = new JLabel(timeText);
+ timeLabel.setFont(new Font(textFont, Font.PLAIN, Constants.TIME_LABEL_TEXT_FONT_SIZE));
+ timeLabel.setForeground(new Color(Constants.TIME_LABEL_BACKGROUND_COLOR_R,
+ Constants.TIME_LABEL_BACKGROUND_COLOR_G,
+ Constants.TIME_LABEL_BACKGROUND_COLOR_B));
+ timeLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ infoPanel.add(nameLabel);
+ infoPanel.add(Box.createVerticalStrut(Constants.INFO_PANEL_BOX_VERTICAL_STRUC_HEIGHT));
+ infoPanel.add(locationLabel);
+ infoPanel.add(Box.createVerticalStrut(Constants.INFO_PANEL_BOX_VERTICAL_STRUC_HEIGHT));
+ infoPanel.add(timeLabel);
+
+ card.add(infoPanel, BorderLayout.CENTER);
+
+ // Button that navigates to event description view
+ final JButton exploreButton = createExploreButton();
+ exploreButton.setUI(new javax.swing.plaf.basic.BasicButtonUI());
+
+ // Add hover effect
+ exploreButton.addMouseListener(new java.awt.event.MouseAdapter() {
+ @Override
+ public void mouseEntered(java.awt.event.MouseEvent e) {
+ exploreButton.setBackground(new Color(Constants.EXPLORE_BUTTON_MOUSE_ENTER_COLOR_R,
+ Constants.EXPLORE_BUTTON_MOUSE_ENTER_COLOR_G,
+ Constants.EXPLORE_BUTTON_MOUSE_ENTER_COLOR_B));
+ }
+
+ @Override
+ public void mouseExited(java.awt.event.MouseEvent e) {
+ exploreButton.setBackground(new Color(Constants.EXPLORE_BUTTON_MOUSE_EXITED_COLOR_R,
+ Constants.EXPLORE_BUTTON_MOUSE_EXITED_COLOR_G,
+ Constants.EXPLORE_BUTTON_MOUSE_EXITED_COLOR_B));
+ }
+ });
+
+ // Navigate to event description view when clicked
+ exploreButton.addActionListener(eve -> {
+ System.out.println("Explore event: " + event.getName());
+ if (eventSelectionListener != null) {
+ eventSelectionListener.onEventSelected(event);
+ }
+ });
+
+ card.add(exploreButton, BorderLayout.EAST);
+
+ return card;
+ }
+
+ @NotNull
+ private JButton createExploreButton() {
+ final JButton exploreButton = new JButton("->");
+ exploreButton.setFont(new Font(textFont, Font.BOLD, Constants.EXPLORE_BUTTON_FONT_SIZE));
+ exploreButton.setFocusPainted(false);
+ exploreButton.setOpaque(true);
+ exploreButton.setContentAreaFilled(true);
+ exploreButton.setBorderPainted(false);
+ exploreButton.setBackground(new Color(Constants.EXPLORE_BUTTON_BACKGROUND_COLOR_R,
+ Constants.EXPLORE_BUTTON_BACKGROUND_COLOR_G,
+ Constants.EXPLORE_BUTTON_BACKGROUND_COLOR_B));
+ exploreButton.setForeground(Color.WHITE);
+ exploreButton.setBorder(BorderFactory.createEmptyBorder(
+ Constants.EXPLORE_BUTTON_EMPTY_BOARDER_TOP,
+ Constants.EXPLORE_BUTTON_EMPTY_BOARDER_LEFT,
+ Constants.EXPLORE_BUTTON_EMPTY_BOARDER_BOTTOM,
+ Constants.EXPLORE_BUTTON_EMPTY_BOARDER_RIGHT));
+ exploreButton.setPreferredSize(new Dimension(Constants.EXPLORE_BUTTON_PREFERRED_WIDTH,
+ Constants.EXPLORE_BUTTON_PREFERRED_HEIGHT));
+ exploreButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
+ return exploreButton;
+ }
+
+ @NotNull
+ private JLabel createLocationLabel(Event event) {
+ final JLabel locationLabel = new JLabel(event.getLocation().getAddress());
+ locationLabel.setFont(new Font(textFont, Font.PLAIN, Constants.LOCATION_LABEL_TEXT_FONT_SIZE));
+ locationLabel.setForeground(new Color(Constants.LOCATION_LABEL_BACKGROUND_COLOR_R,
+ Constants.LOCATION_LABEL_BACKGROUND_COLOR_G,
+ Constants.LOCATION_LABEL_BACKGROUND_COLOR_B));
+ locationLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+ return locationLabel;
+ }
+
+ @NotNull
+ private static JLabel createNameLabel(Event event) {
+ final JLabel nameLabel = new JLabel(event.getName());
+ nameLabel.setFont(nameLabel.getFont().deriveFont(Font.BOLD, Constants.NAMEL_LABEL_TEXT_FONT_SIZE));
+ nameLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+ return nameLabel;
+ }
+
+ @NotNull
+ private static JPanel createCardBasePanel() {
+ final JPanel card = new JPanel(new BorderLayout());
+ card.setMaximumSize(new Dimension(Integer.MAX_VALUE, Constants.CARD_BASE_PANEL_MAXIMUM_SIZE_HEIGHT));
+ card.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createLineBorder(new Color(Constants.CARD_BASE_PANEL_LINE_BOARDER_COLOR_R,
+ Constants.CARD_BASE_PANEL_LINE_BOARDER_COLOR_G,
+ Constants.CARD_BASE_PANEL_LINE_BOARDER_COLOR_B), 1),
+ new EmptyBorder(Constants.CARD_BASE_PANEL_EMPTY_BOARDER_TOP,
+ Constants.CARD_BASE_PANEL_EMPTY_BOARDER_LEFT,
+ Constants.CARD_BASE_PANEL_EMPTY_BOARDER_BOTTOM,
+ Constants.CARD_BASE_PANEL_EMPTY_BOARDER_RIGHT)
+ ));
+ card.setBackground(Color.WHITE);
+ return card;
+ }
+
+ @NotNull
+ private static JPanel createInfoPanel() {
+ final JPanel infoPanel = new JPanel();
+ infoPanel.setLayout(new BoxLayout(infoPanel, BoxLayout.Y_AXIS));
+ infoPanel.setOpaque(false);
+ return infoPanel;
+ }
+
+ public String getViewName() {
+ return viewName;
+ }
+
+ /**
+ * Listener interface for handling event selection actions.
+ */
+ public interface EventSelectionListener {
+ /**
+ * Called when an event is selected by the user.
+ * @param event event the event that was selected
+ */
+ void onEventSelected(Event event);
+ }
+}
diff --git a/src/main/java/view/LabelTextPanel.java b/src/main/java/view/LabelTextPanel.java
index 66bc10c4..db1d81f3 100644
--- a/src/main/java/view/LabelTextPanel.java
+++ b/src/main/java/view/LabelTextPanel.java
@@ -1,13 +1,28 @@
package view;
import javax.swing.*;
+import java.awt.*;
/**
* A panel containing a label and a text field.
*/
class LabelTextPanel extends JPanel {
LabelTextPanel(JLabel label, JTextField textField) {
- this.add(label);
- this.add(textField);
+ setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
+ setOpaque(false);
+ label.setFont(new Font("SegoeUI", Font.BOLD, 14));
+ textField.setFont(new Font("SegoeUI", Font.PLAIN, 14));
+
+ label.setAlignmentX(Component.LEFT_ALIGNMENT);
+ textField.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ Dimension fieldSize = new Dimension(250, 40); // width 250px, height 30px
+ textField.setMaximumSize(fieldSize);
+ textField.setPreferredSize(fieldSize);
+ textField.setMinimumSize(fieldSize);
+
+ add(label);
+ add(Box.createRigidArea(new Dimension(0, 5)));
+ add(textField);
}
}
diff --git a/src/main/java/view/LoggedInView.java b/src/main/java/view/LoggedInView.java
index f38cc220..194e52cb 100644
--- a/src/main/java/view/LoggedInView.java
+++ b/src/main/java/view/LoggedInView.java
@@ -1,5 +1,6 @@
package view;
+import interface_adapter.ViewNames;
import interface_adapter.logged_in.ChangePasswordController;
import interface_adapter.logged_in.LoggedInState;
import interface_adapter.logged_in.LoggedInViewModel;
@@ -19,11 +20,11 @@
*/
public class LoggedInView extends JPanel implements ActionListener, PropertyChangeListener {
- private final String viewName = "logged in";
+ private final String viewName = ViewNames.LOGGED_IN;
private final LoggedInViewModel loggedInViewModel;
private final JLabel passwordErrorField = new JLabel();
private ChangePasswordController changePasswordController = null;
- private LogoutController logoutController;
+ private LogoutController logoutController = null;
private final JLabel username;
@@ -108,9 +109,13 @@ public void changedUpdate(DocumentEvent e) {
* @param evt the ActionEvent to react to
*/
public void actionPerformed(ActionEvent evt) {
- System.out.println("Click " + evt.getActionCommand());
+
+ if (evt.getSource().equals(logOut)) {
+ logoutController.execute();
+ }
}
+
@Override
public void propertyChange(PropertyChangeEvent evt) {
if (evt.getPropertyName().equals("state")) {
@@ -139,6 +144,6 @@ public void setChangePasswordController(ChangePasswordController changePasswordC
}
public void setLogoutController(LogoutController logoutController) {
- // TODO: save the logout controller in the instance variable.
+ this.logoutController = logoutController;
}
}
diff --git a/src/main/java/view/LoginView.java b/src/main/java/view/LoginView.java
index f7809810..5ab9e8b6 100644
--- a/src/main/java/view/LoginView.java
+++ b/src/main/java/view/LoginView.java
@@ -1,8 +1,10 @@
package view;
+import interface_adapter.ViewNames;
import interface_adapter.login.LoginController;
import interface_adapter.login.LoginState;
import interface_adapter.login.LoginViewModel;
+import interface_adapter.signup.SignupViewModel;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
@@ -18,7 +20,7 @@
*/
public class LoginView extends JPanel implements ActionListener, PropertyChangeListener {
- private final String viewName = "log in";
+ private final String viewName = ViewNames.LOGIN;
private final LoginViewModel loginViewModel;
private final JTextField usernameInputField = new JTextField(15);
@@ -33,21 +35,40 @@ public class LoginView extends JPanel implements ActionListener, PropertyChangeL
public LoginView(LoginViewModel loginViewModel) {
+ this.setLayout(new GridLayout(1, 2));
this.loginViewModel = loginViewModel;
this.loginViewModel.addPropertyChangeListener(this);
- final JLabel title = new JLabel("Login Screen");
+ JPanel leftPanel = createBrandPanel();
+ JPanel rightPanel = new JPanel();
+ rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.Y_AXIS));
+ rightPanel.setBorder(BorderFactory.createEmptyBorder(100, 0, 0, 0));
+
+ final JLabel title = new JLabel(LoginViewModel.TITLE_LABEL);
title.setAlignmentX(Component.CENTER_ALIGNMENT);
+ title.setFont(new Font("SegoeUI", Font.BOLD, 36));
+
+ JLabel subtitleLabel = new JLabel(LoginViewModel.CAPTION);
+ subtitleLabel.setFont(new Font("SegoeUI", Font.PLAIN, 14));
+ subtitleLabel.setForeground(new Color(107, 114, 128));
+ subtitleLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
final LabelTextPanel usernameInfo = new LabelTextPanel(
new JLabel("Username"), usernameInputField);
+ usernameInfo.setAlignmentX(Component.CENTER_ALIGNMENT);
final LabelTextPanel passwordInfo = new LabelTextPanel(
new JLabel("Password"), passwordInputField);
+ passwordInfo.setAlignmentX(Component.CENTER_ALIGNMENT);
final JPanel buttons = new JPanel();
- logIn = new JButton("log in");
+ buttons.setAlignmentX(Component.CENTER_ALIGNMENT);
+ logIn = new JButton("Log In");
buttons.add(logIn);
- cancel = new JButton("cancel");
+ cancel = new JButton("Back");
+
+ styleButton(logIn, new Color(0,0,0,0));
+ styleButton(cancel, new Color(0,0,0,0));
buttons.add(cancel);
logIn.addActionListener(
@@ -55,7 +76,6 @@ public LoginView(LoginViewModel loginViewModel) {
public void actionPerformed(ActionEvent evt) {
if (evt.getSource().equals(logIn)) {
final LoginState currentState = loginViewModel.getState();
-
loginController.execute(
currentState.getUsername(),
currentState.getPassword()
@@ -65,7 +85,14 @@ public void actionPerformed(ActionEvent evt) {
}
);
- cancel.addActionListener(this);
+ cancel.addActionListener(
+ new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ loginController.switchToSignUpView();
+ }
+ }
+ );
usernameInputField.getDocument().addDocumentListener(new DocumentListener() {
@@ -91,8 +118,6 @@ public void changedUpdate(DocumentEvent e) {
}
});
- this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
-
passwordInputField.getDocument().addDocumentListener(new DocumentListener() {
private void documentListenerHelper() {
@@ -117,13 +142,96 @@ public void changedUpdate(DocumentEvent e) {
}
});
- this.add(title);
- this.add(usernameInfo);
- this.add(usernameErrorField);
- this.add(passwordInfo);
- this.add(buttons);
+ JPanel titlePanel = new JPanel();
+ titlePanel.setLayout(new BoxLayout(titlePanel, BoxLayout.Y_AXIS));
+ titlePanel.setOpaque(false);
+ titlePanel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ titlePanel.add(title);
+ titlePanel.add(Box.createRigidArea(new Dimension(0, 10)));
+ titlePanel.add(subtitleLabel);
+
+ JPanel formPanel = new JPanel();
+ formPanel.setLayout(new BoxLayout(formPanel, BoxLayout.Y_AXIS));
+ formPanel.setOpaque(false);
+ formPanel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ formPanel.add(usernameInfo);
+ formPanel.add(Box.createRigidArea(new Dimension(0, 20)));
+
+ formPanel.add(passwordInfo);
+ formPanel.add(Box.createRigidArea(new Dimension(0, 20)));
+
+ formPanel.add(buttons);
+
+ rightPanel.add(titlePanel);
+ rightPanel.add(Box.createRigidArea(new Dimension(0, 20)));
+ rightPanel.add(formPanel);
+
+ leftPanel.setPreferredSize(new Dimension(400, 600));
+ rightPanel.setPreferredSize(new Dimension(400, 600));
+
+ this.add(leftPanel);
+ this.add(rightPanel);
}
+ private JPanel createBrandPanel() {
+ JPanel panel = new JPanel() {
+ @Override
+ protected void paintComponent(Graphics g) {
+ super.paintComponent(g);
+ // Extension of the Graphics class to allow for gradients
+ Graphics2D g2d = (Graphics2D) g;
+ g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+ // Create gradient
+ GradientPaint gradient = new GradientPaint(
+ 0, 0, new Color(10, 103, 198),
+ getWidth(), getHeight(), new Color(13, 133, 251)
+ );
+ g2d.setPaint(gradient);
+ g2d.fillRect(0, 0, getWidth(), getHeight());
+
+ // Draw decorative circles
+ g2d.setColor(new Color(255, 255, 255, 30));
+ g2d.fillOval(-50, -50, 200, 200);
+ g2d.fillOval(getWidth() - 150, getHeight() - 150, 200, 200);
+ }
+ };
+ panel.setLayout(new GridBagLayout());
+
+ JPanel content = new JPanel();
+ content.setOpaque(false);
+ content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
+
+ JLabel title = new JLabel(SignupViewModel.TITLE);
+ title.setFont(new Font("Segoe UI", Font.BOLD, 36));
+ title.setForeground(Color.WHITE);
+ title.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ JLabel subtitle = new JLabel(SignupViewModel.CAPTION);
+ subtitle.setFont(new Font("Segoe UI", Font.PLAIN, 16));
+ subtitle.setForeground(new Color(255, 255, 255, 200));
+ subtitle.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ content.add(title);
+ content.add(Box.createRigidArea(new Dimension(0, 10)));
+ content.add(subtitle);
+
+ panel.add(content);
+ return panel;
+ }
+
+ private void styleButton(JButton button, Color color) {
+ button.setFont(new Font("SegoeUI", Font.BOLD, 14));
+ button.setForeground(Color.BLUE);
+ button.setBackground(color);
+ button.setFocusPainted(false);
+ button.setBorderPainted(false);
+ button.setCursor(new Cursor(Cursor.HAND_CURSOR));
+ }
+
+
/**
* React to a button click that results in evt.
* @param evt the ActionEvent to react to
diff --git a/src/main/java/view/SaveButtonView.java b/src/main/java/view/SaveButtonView.java
new file mode 100644
index 00000000..b12683c1
--- /dev/null
+++ b/src/main/java/view/SaveButtonView.java
@@ -0,0 +1,194 @@
+package view;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JPanel;
+import javax.swing.Timer;
+
+import entity.Event;
+import interface_adapter.save_event.SaveEventController;
+
+/**
+ * View for the save event button.
+ */
+public class SaveButtonView extends JPanel {
+
+ private static final int BUTTON_WIDTH = 160;
+ private static final int BUTTON_HEIGHT = 45;
+ private static final int BORDER_WIDTH_NORMAL = 3;
+ private static final int BORDER_WIDTH_HOVER = 2;
+ private static final int FONT_SIZE = 14;
+ private static final int RESET_DELAY = 10000;
+
+ private static final Color BASE_COLOR = new Color(59, 130, 246);
+ private static final Color PRESSED_BACKGROUND_COLOR = new Color(37, 99, 235);
+ private static final Color WHITE_COLOR = Color.WHITE;
+
+ private static final String FONT_NAME = "Segoe UI";
+ private static final String SAVE_BUTTON_TEXT = "Save Event";
+ private static final String SAVED_BUTTON_TEXT = "Saved";
+ private static final String YIPPEE_MESSAGE = "YIPPEE";
+
+ private final String viewName = "save";
+ private JButton saveButton;
+ private Event event;
+ private SaveEventController saveButtonController;
+ private Timer resetTimer;
+
+ /**
+ * Constructor for SaveButtonView.
+ */
+ public SaveButtonView() {
+ initializeButton();
+ addActionListeners();
+ add(saveButton);
+ }
+
+ private void initializeButton() {
+ saveButton = new JButton(SAVE_BUTTON_TEXT);
+ saveButton.setFont(new Font(FONT_NAME, Font.BOLD, FONT_SIZE));
+ saveButton.setForeground(BASE_COLOR);
+ saveButton.setBackground(WHITE_COLOR);
+ saveButton.setBorder(BorderFactory.createLineBorder(BASE_COLOR, BORDER_WIDTH_NORMAL));
+ saveButton.setPreferredSize(new Dimension(BUTTON_WIDTH, BUTTON_HEIGHT));
+ saveButton.setContentAreaFilled(false);
+ saveButton.setOpaque(true);
+ }
+
+ private void addActionListeners() {
+ addMouseListeners();
+ addActionListener();
+ }
+
+ private void addMouseListeners() {
+ saveButton.addMouseListener(new MouseAdapter() {
+ @Override
+ public void mouseEntered(final MouseEvent mouseEvent) {
+ handleMouseEntered();
+ }
+
+ @Override
+ public void mouseExited(final MouseEvent mouseEvent) {
+ handleMouseExited();
+ }
+
+ @Override
+ public void mousePressed(final MouseEvent mouseEvent) {
+ handleMousePressed();
+ }
+
+ @Override
+ public void mouseReleased(final MouseEvent mouseEvent) {
+ handleMouseReleased(mouseEvent);
+ }
+ });
+ }
+
+ private void handleMouseEntered() {
+ saveButton.setBackground(BASE_COLOR);
+ saveButton.setForeground(WHITE_COLOR);
+ saveButton.setBorder(BorderFactory.createLineBorder(WHITE_COLOR, BORDER_WIDTH_HOVER));
+ }
+
+ private void handleMouseExited() {
+ saveButton.setBackground(WHITE_COLOR);
+ saveButton.setForeground(BASE_COLOR);
+ saveButton.setBorder(BorderFactory.createLineBorder(BASE_COLOR, BORDER_WIDTH_NORMAL));
+ }
+
+ private void handleMousePressed() {
+ saveButton.setBackground(PRESSED_BACKGROUND_COLOR);
+ saveButton.setBorder(BorderFactory.createLineBorder(PRESSED_BACKGROUND_COLOR,
+ BORDER_WIDTH_HOVER));
+ }
+
+ private void handleMouseReleased(final MouseEvent mouseEvent) {
+ if (saveButton.contains(mouseEvent.getPoint())) {
+ saveButton.setBackground(BASE_COLOR);
+ saveButton.setBorder(BorderFactory.createLineBorder(BASE_COLOR, BORDER_WIDTH_HOVER));
+ }
+ else {
+ saveButton.setBackground(WHITE_COLOR);
+ saveButton.setForeground(BASE_COLOR);
+ saveButton.setBorder(BorderFactory.createLineBorder(BASE_COLOR, BORDER_WIDTH_HOVER));
+ }
+ }
+
+ private void addActionListener() {
+ saveButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(final ActionEvent actionEvent) {
+ handleSaveAction();
+ }
+ });
+ }
+
+ private void handleSaveAction() {
+ if (saveButtonController != null && event != null) {
+ saveButtonController.saveEvent(event);
+ saveButton.setText(SAVED_BUTTON_TEXT);
+ saveButton.setEnabled(false);
+ startResetTimer();
+ }
+ }
+
+ private void startResetTimer() {
+ if (resetTimer != null && resetTimer.isRunning()) {
+ resetTimer.stop();
+ }
+
+ resetTimer = new Timer(RESET_DELAY, new ActionListener() {
+ @Override
+ public void actionPerformed(final ActionEvent actionEvent) {
+ resetButtonState();
+ }
+ });
+ resetTimer.setRepeats(false);
+ resetTimer.start();
+ }
+
+ private void resetButtonState() {
+ if (saveButton != null) {
+ saveButton.setText(SAVE_BUTTON_TEXT);
+ saveButton.setEnabled(true);
+ saveButton.setForeground(BASE_COLOR);
+ saveButton.setBackground(WHITE_COLOR);
+ saveButton.setBorder(BorderFactory.createLineBorder(BASE_COLOR, BORDER_WIDTH_NORMAL));
+ }
+ }
+
+ /**
+ * Sets the event to be saved.
+ *
+ * @param newEvent the event to set
+ */
+ public void setEvent(final Event newEvent) {
+ this.event = newEvent;
+ }
+
+ /**
+ * Sets the save event controller.
+ *
+ * @param controller the controller to set
+ */
+ public void setSaveEventController(final SaveEventController controller) {
+ this.saveButtonController = controller;
+ }
+
+ /**
+ * Gets the view name.
+ *
+ * @return the view name
+ */
+ public String getViewName() {
+ return viewName;
+ }
+}
diff --git a/src/main/java/view/SaveEventsView.java b/src/main/java/view/SaveEventsView.java
new file mode 100644
index 00000000..c3957ba2
--- /dev/null
+++ b/src/main/java/view/SaveEventsView.java
@@ -0,0 +1,438 @@
+package view;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.Font;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+import javax.swing.BorderFactory;
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.SwingConstants;
+import javax.swing.border.EmptyBorder;
+
+import entity.Event;
+import interface_adapter.ViewManagerModel;
+import interface_adapter.ViewNames;
+import interface_adapter.save_event.SaveEventController;
+import interface_adapter.save_event.SaveEventViewModel;
+import use_case.save_event.SaveEventInteractor;
+
+/**
+ * View for displaying saved events.
+ * Shows all events the user has saved and allows them to remove events.
+ * Automatically refreshes when the view becomes visible.
+ */
+public class SaveEventsView extends JPanel implements PropertyChangeListener {
+
+ private static final int HEADER_PADDING = 15;
+ private static final int HEADER_BUTTON_PADDING = 8;
+ private static final int CONTAINER_PADDING = 20;
+ private static final int SCROLL_UNIT = 16;
+ private static final int HEADER_FONT_SIZE = 20;
+ private static final int BUTTON_FONT_SIZE = 14;
+ private static final int SMALL_BUTTON_FONT_SIZE = 12;
+ private static final int EMPTY_ICON_SIZE = 48;
+ private static final int EMPTY_TITLE_SIZE = 24;
+ private static final int COUNT_FONT_SIZE = 14;
+ private static final int CARD_FONT_SIZE = 16;
+ private static final int BADGE_FONT_SIZE = 10;
+ private static final int CARD_SPACING = 12;
+ private static final int CARD_PADDING = 15;
+ private static final int MAX_CARD_HEIGHT = 120;
+ private static final int MAX_NAME_LENGTH = 50;
+ private static final int MAX_ADDRESS_LENGTH = 60;
+
+ private static final Color BACKGROUND_COLOR = new Color(245, 247, 250);
+ private static final Color HEADER_COLOR = new Color(25, 118, 210);
+ private static final Color HEADER_HOVER = new Color(21, 101, 192);
+ private static final Color PRIMARY_BLUE = new Color(59, 130, 246);
+ private static final Color BADGE_BLUE = new Color(219, 234, 254);
+ private static final Color CARD_BORDER = new Color(230, 230, 230);
+ private static final Color CARD_HOVER = new Color(250, 250, 250);
+ private static final Color ERROR_RED = new Color(220, 53, 69);
+ private static final Color ERROR_BG = new Color(255, 240, 240);
+ private static final Color TEXT_DARK = new Color(30, 30, 30);
+ private static final Color TEXT_GRAY = new Color(100, 100, 100);
+ private static final Color TEXT_LIGHT_GRAY = new Color(120, 120, 120);
+ private static final Color TEXT_MEDIUM_GRAY = new Color(150, 150, 150);
+ private static final Color TEXT_DARK_GRAY = new Color(50, 50, 50);
+
+ private final String viewName = ViewNames.SAVE_EVENTS;
+ private final SaveEventViewModel viewModel;
+ private ViewManagerModel viewManagerModel;
+ private SaveEventInteractor saveEventInteractor;
+ private SaveEventController saveEventController;
+
+ private final JPanel eventsContainer = new JPanel();
+ private final JButton backButton = new JButton("<- Back to Events");
+ private final DateTimeFormatter dateFormatter =
+ DateTimeFormatter.ofPattern("EEEE, MMMM d, yyyy 'at' h:mm a");
+
+ public SaveEventsView(SaveEventViewModel viewModel) {
+ this.viewModel = viewModel;
+ this.viewModel.addPropertyChangeListener(this);
+
+ setLayout(new BorderLayout());
+ setBackground(BACKGROUND_COLOR);
+
+ add(createHeader(), BorderLayout.NORTH);
+
+ eventsContainer.setLayout(new BoxLayout(eventsContainer, BoxLayout.Y_AXIS));
+ eventsContainer.setBackground(BACKGROUND_COLOR);
+ eventsContainer.setBorder(new EmptyBorder(CONTAINER_PADDING, CONTAINER_PADDING,
+ CONTAINER_PADDING, CONTAINER_PADDING));
+
+ final JScrollPane scrollPane = new JScrollPane(eventsContainer);
+ scrollPane.setBorder(null);
+ scrollPane.getVerticalScrollBar().setUnitIncrement(SCROLL_UNIT);
+ scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
+ scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
+ add(scrollPane, BorderLayout.CENTER);
+
+ addComponentListener(new java.awt.event.ComponentAdapter() {
+ @Override
+ public void componentShown(java.awt.event.ComponentEvent evt) {
+ renderSavedEvents();
+ }
+ });
+
+ renderSavedEvents();
+ }
+
+ private JPanel createHeader() {
+ final JPanel header = new JPanel(new BorderLayout());
+ header.setBackground(HEADER_COLOR);
+ header.setBorder(new EmptyBorder(HEADER_PADDING, CONTAINER_PADDING,
+ HEADER_PADDING, CONTAINER_PADDING));
+
+ backButton.setFont(new Font("Segoe UI", Font.PLAIN, BUTTON_FONT_SIZE));
+ backButton.setForeground(Color.WHITE);
+ backButton.setBackground(HEADER_COLOR);
+ backButton.setBorder(BorderFactory.createEmptyBorder(HEADER_BUTTON_PADDING,
+ HEADER_PADDING, HEADER_BUTTON_PADDING, HEADER_PADDING));
+ backButton.setFocusPainted(false);
+ backButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
+ backButton.setOpaque(true);
+ backButton.setContentAreaFilled(false);
+
+ backButton.addMouseListener(new java.awt.event.MouseAdapter() {
+ @Override
+ public void mouseEntered(java.awt.event.MouseEvent evt) {
+ backButton.setContentAreaFilled(true);
+ backButton.setBackground(HEADER_HOVER);
+ }
+
+ @Override
+ public void mouseExited(java.awt.event.MouseEvent evt) {
+ backButton.setContentAreaFilled(false);
+ }
+ });
+
+ backButton.addActionListener(evt -> navigateBack());
+ header.add(backButton, BorderLayout.WEST);
+
+ final JLabel title = new JLabel("Your Saved Events");
+ title.setFont(new Font("Segoe UI", Font.BOLD, HEADER_FONT_SIZE));
+ title.setForeground(Color.WHITE);
+ title.setHorizontalAlignment(SwingConstants.CENTER);
+ header.add(title, BorderLayout.CENTER);
+
+ final JButton refreshButton = new JButton("Refresh");
+ refreshButton.setFont(new Font("Segoe UI", Font.PLAIN, SMALL_BUTTON_FONT_SIZE));
+ refreshButton.setForeground(Color.WHITE);
+ refreshButton.setBackground(HEADER_COLOR);
+ refreshButton.setBorder(BorderFactory.createEmptyBorder(HEADER_BUTTON_PADDING,
+ HEADER_PADDING, HEADER_BUTTON_PADDING, HEADER_PADDING));
+ refreshButton.setFocusPainted(false);
+ refreshButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
+ refreshButton.setContentAreaFilled(false);
+ refreshButton.addActionListener(evt -> renderSavedEvents());
+ header.add(refreshButton, BorderLayout.EAST);
+
+ return header;
+ }
+
+ private void navigateBack() {
+ if (viewManagerModel != null) {
+ viewManagerModel.setState("display local events");
+ viewManagerModel.firePropertyChange();
+ }
+ }
+
+ /**
+ * Render the saved events list.
+ * Called on initial load, when view becomes visible, and when events change.
+ */
+ public void renderSavedEvents() {
+ eventsContainer.removeAll();
+
+ List savedEvents = null;
+ if (saveEventInteractor != null) {
+ savedEvents = saveEventInteractor.getSavedEvents();
+ System.out.println("Loaded " + (savedEvents != null ? savedEvents.size() : 0)
+ + " saved events");
+ }
+
+ if (savedEvents == null || savedEvents.isEmpty()) {
+ renderEmptyState();
+ }
+ else {
+ eventsContainer.setLayout(new BoxLayout(eventsContainer, BoxLayout.Y_AXIS));
+
+ final JLabel countLabel = new JLabel("You have " + savedEvents.size() + " saved event"
+ + (savedEvents.size() == 1 ? "" : "s"));
+ countLabel.setFont(new Font("Segoe UI", Font.PLAIN, COUNT_FONT_SIZE));
+ countLabel.setForeground(TEXT_GRAY);
+ countLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+ countLabel.setBorder(new EmptyBorder(0, 0, HEADER_PADDING, 0));
+ eventsContainer.add(countLabel);
+
+ for (Event event : savedEvents) {
+ final JPanel card = createEventCard(event);
+ card.setAlignmentX(Component.LEFT_ALIGNMENT);
+ eventsContainer.add(card);
+ eventsContainer.add(Box.createVerticalStrut(CARD_SPACING));
+ }
+
+ eventsContainer.add(Box.createVerticalGlue());
+ }
+
+ eventsContainer.revalidate();
+ eventsContainer.repaint();
+ }
+
+ private void renderEmptyState() {
+ eventsContainer.setLayout(new GridBagLayout());
+
+ final JPanel emptyPanel = new JPanel();
+ emptyPanel.setLayout(new BoxLayout(emptyPanel, BoxLayout.Y_AXIS));
+ emptyPanel.setBackground(BACKGROUND_COLOR);
+ emptyPanel.setBorder(new EmptyBorder(MAX_NAME_LENGTH, MAX_NAME_LENGTH,
+ MAX_NAME_LENGTH, MAX_NAME_LENGTH));
+
+ final JLabel iconLabel = new JLabel("📅", SwingConstants.CENTER);
+ iconLabel.setFont(new Font("Segoe UI", Font.BOLD, EMPTY_ICON_SIZE));
+ iconLabel.setForeground(TEXT_MEDIUM_GRAY);
+ iconLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ final JLabel titleLabel = new JLabel("No Saved Events Yet");
+ titleLabel.setFont(new Font("Segoe UI", Font.BOLD, EMPTY_TITLE_SIZE));
+ titleLabel.setForeground(TEXT_DARK_GRAY);
+ titleLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ final JLabel descLabel = new JLabel(""
+ + "Events you save will appear here.
"
+ + "Click 'Save Event' on any event to add it!
");
+ descLabel.setFont(new Font("Segoe UI", Font.PLAIN, COUNT_FONT_SIZE));
+ descLabel.setForeground(TEXT_LIGHT_GRAY);
+ descLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
+ descLabel.setHorizontalAlignment(SwingConstants.CENTER);
+
+ final JButton browseButton = new JButton("Browse Events");
+ browseButton.setFont(new Font("Segoe UI", Font.BOLD, BUTTON_FONT_SIZE));
+ browseButton.setForeground(Color.WHITE);
+ browseButton.setBackground(PRIMARY_BLUE);
+ browseButton.setBorder(new EmptyBorder(CARD_SPACING, EMPTY_TITLE_SIZE,
+ CARD_SPACING, EMPTY_TITLE_SIZE));
+ browseButton.setFocusPainted(false);
+ browseButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
+ browseButton.setAlignmentX(Component.CENTER_ALIGNMENT);
+ browseButton.addActionListener(evt -> navigateBack());
+
+ emptyPanel.add(iconLabel);
+ emptyPanel.add(Box.createVerticalStrut(CONTAINER_PADDING));
+ emptyPanel.add(titleLabel);
+ emptyPanel.add(Box.createVerticalStrut(CARD_SPACING));
+ emptyPanel.add(descLabel);
+ emptyPanel.add(Box.createVerticalStrut(EMPTY_TITLE_SIZE + 1));
+ emptyPanel.add(browseButton);
+
+ final GridBagConstraints gbc = new GridBagConstraints();
+ gbc.gridx = 0;
+ gbc.gridy = 0;
+ gbc.weightx = 1.0;
+ gbc.weighty = 1.0;
+ gbc.anchor = GridBagConstraints.CENTER;
+
+ eventsContainer.add(emptyPanel, gbc);
+ }
+
+ private JPanel createEventCard(Event event) {
+ final JPanel card = new JPanel(new BorderLayout(HEADER_PADDING, 0));
+ card.setBackground(Color.WHITE);
+ card.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createLineBorder(CARD_BORDER),
+ new EmptyBorder(CARD_PADDING, CARD_PADDING, CARD_PADDING, CARD_PADDING)
+ ));
+ card.setMaximumSize(new Dimension(Integer.MAX_VALUE, MAX_CARD_HEIGHT));
+
+ final JPanel infoPanel = new JPanel();
+ infoPanel.setLayout(new BoxLayout(infoPanel, BoxLayout.Y_AXIS));
+ infoPanel.setOpaque(false);
+
+ final String eventName = truncateText(event.getName(), MAX_NAME_LENGTH);
+ final JLabel nameLabel = new JLabel(eventName);
+ nameLabel.setFont(new Font("Segoe UI", Font.BOLD, CARD_FONT_SIZE));
+ nameLabel.setForeground(TEXT_DARK);
+ nameLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ final JLabel categoryLabel = new JLabel(event.getCategory().getDisplayName());
+ categoryLabel.setFont(new Font("Segoe UI", Font.BOLD, BADGE_FONT_SIZE));
+ categoryLabel.setForeground(PRIMARY_BLUE);
+ categoryLabel.setOpaque(true);
+ categoryLabel.setBackground(BADGE_BLUE);
+ categoryLabel.setBorder(new EmptyBorder(2, HEADER_BUTTON_PADDING,
+ 2, HEADER_BUTTON_PADDING));
+ categoryLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ final String address = event.getLocation() != null
+ ? event.getLocation().getAddress() : "Location not available";
+ final String truncatedAddress = truncateText(address, MAX_ADDRESS_LENGTH);
+ final JLabel locationLabel = new JLabel(truncatedAddress);
+ locationLabel.setFont(new Font("Segoe UI", Font.PLAIN, SMALL_BUTTON_FONT_SIZE));
+ locationLabel.setForeground(TEXT_GRAY);
+ locationLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ final String dateTimeStr = event.getStartTime() != null
+ ? event.getStartTime().format(dateFormatter) : "Date not available";
+ final JLabel dateLabel = new JLabel(dateTimeStr);
+ dateLabel.setFont(new Font("Segoe UI", Font.PLAIN, SMALL_BUTTON_FONT_SIZE));
+ dateLabel.setForeground(TEXT_GRAY);
+ dateLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ final int spacing = 5;
+ infoPanel.add(nameLabel);
+ infoPanel.add(Box.createVerticalStrut(spacing));
+ infoPanel.add(categoryLabel);
+ infoPanel.add(Box.createVerticalStrut(HEADER_BUTTON_PADDING));
+ infoPanel.add(locationLabel);
+ infoPanel.add(Box.createVerticalStrut(spacing / 2));
+ infoPanel.add(dateLabel);
+
+ card.add(infoPanel, BorderLayout.CENTER);
+
+ final JButton removeButton = new JButton("Remove");
+ removeButton.setFont(new Font("Segoe UI", Font.PLAIN, SMALL_BUTTON_FONT_SIZE));
+ removeButton.setForeground(ERROR_RED);
+ removeButton.setBackground(Color.WHITE);
+ removeButton.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createLineBorder(ERROR_RED),
+ new EmptyBorder(HEADER_BUTTON_PADDING, CARD_SPACING,
+ HEADER_BUTTON_PADDING, CARD_SPACING)
+ ));
+ removeButton.setFocusPainted(false);
+ removeButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
+
+ removeButton.addMouseListener(new java.awt.event.MouseAdapter() {
+ @Override
+ public void mouseEntered(java.awt.event.MouseEvent evt) {
+ removeButton.setBackground(ERROR_BG);
+ }
+
+ @Override
+ public void mouseExited(java.awt.event.MouseEvent evt) {
+ removeButton.setBackground(Color.WHITE);
+ }
+ });
+
+ removeButton.addActionListener(evt -> handleRemoveEvent(event));
+
+ final JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+ buttonPanel.setOpaque(false);
+ buttonPanel.add(removeButton);
+ card.add(buttonPanel, BorderLayout.EAST);
+
+ card.addMouseListener(new java.awt.event.MouseAdapter() {
+ @Override
+ public void mouseEntered(java.awt.event.MouseEvent evt) {
+ card.setBackground(CARD_HOVER);
+ card.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createLineBorder(PRIMARY_BLUE),
+ new EmptyBorder(CARD_PADDING, CARD_PADDING,
+ CARD_PADDING, CARD_PADDING)
+ ));
+ }
+
+ @Override
+ public void mouseExited(java.awt.event.MouseEvent evt) {
+ card.setBackground(Color.WHITE);
+ card.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createLineBorder(CARD_BORDER),
+ new EmptyBorder(CARD_PADDING, CARD_PADDING,
+ CARD_PADDING, CARD_PADDING)
+ ));
+ }
+ });
+
+ return card;
+ }
+
+ private void handleRemoveEvent(Event event) {
+ final int confirm = JOptionPane.showConfirmDialog(this,
+ "Remove \"" + event.getName() + "\" from saved events?",
+ "Confirm Remove",
+ JOptionPane.YES_NO_OPTION,
+ JOptionPane.QUESTION_MESSAGE);
+
+ if (confirm == JOptionPane.YES_OPTION && saveEventInteractor != null) {
+ saveEventInteractor.unsaveEvent(event);
+ renderSavedEvents();
+ JOptionPane.showMessageDialog(this,
+ "Event removed from saved events.",
+ "Removed", JOptionPane.INFORMATION_MESSAGE);
+ }
+ }
+
+ /**
+ * Truncate text to a maximum length, adding "..." if truncated.
+ * @param text the text to truncate
+ * @param maxLength the maximum length
+ * @return the truncated text
+ */
+ private String truncateText(String text, int maxLength) {
+ if (text == null) {
+ return "";
+ }
+ if (text.length() <= maxLength) {
+ return text;
+ }
+ final int truncateLength = 3;
+ return text.substring(0, maxLength - truncateLength) + "...";
+ }
+
+ public void setViewManagerModel(ViewManagerModel viewManagerModel) {
+ this.viewManagerModel = viewManagerModel;
+ }
+
+ public void setSaveEventInteractor(SaveEventInteractor interactor) {
+ this.saveEventInteractor = interactor;
+ }
+
+ public void setSaveEventController(SaveEventController controller) {
+ this.saveEventController = controller;
+ }
+
+ @Override
+ public void propertyChange(PropertyChangeEvent evt) {
+ renderSavedEvents();
+ }
+
+ public String getViewName() {
+ return viewName;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/view/SearchBarView.java b/src/main/java/view/SearchBarView.java
new file mode 100644
index 00000000..b682cce3
--- /dev/null
+++ b/src/main/java/view/SearchBarView.java
@@ -0,0 +1,119 @@
+package view;
+
+import entity.Location;
+import interface_adapter.search.SearchController;
+
+import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+
+public class SearchBarView extends JPanel {
+ private JTextField searchField;
+ private Color borderColor = new Color(220, 220, 220);
+ private Color focusBorderColor = new Color(180, 180, 180);
+ private Color backgroundColor = new Color(250, 250, 250);
+ private boolean isFocused = false;
+ private String searchDescription = null;
+ private SearchController searchController = null;
+ private Location location = null;
+
+
+ public SearchBarView(String text, Location userLocation) {
+ setLayout(new BorderLayout());
+ setPreferredSize(new Dimension(600, 40));
+ setOpaque(false);
+ this.searchDescription = text;
+ this.location = userLocation;
+ add(initComponents(searchDescription));
+ }
+
+ private JPanel initComponents(String text) {
+ JPanel container = new JPanel(new BorderLayout()) {
+ // Written with the help of generative AI
+ @Override
+ protected void paintComponent(Graphics g) {
+ super.paintComponent(g);
+ Graphics2D g2 = (Graphics2D) g.create();
+ g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+ g2.setColor(new Color(0, 0, 0, 15));
+ g2.fillRoundRect(1, 3, getWidth() - 2, getHeight() - 3, 30, 30);
+
+ g2.setColor(backgroundColor);
+ g2.fillRoundRect(0, 0, getWidth() - 2, getHeight() - 4, 30, 30);
+
+ g2.setColor(isFocused ? focusBorderColor : borderColor);
+ g2.setStroke(new BasicStroke(1.5f));
+ g2.drawRoundRect(0, 0, getWidth() - 2, getHeight() - 4, 30, 30);
+
+ g2.dispose();
+ }
+ };
+ container.setOpaque(false);
+ container.setBorder(new EmptyBorder(5, 20, 5, 20));
+
+ searchField = new JTextField() {
+ @Override
+ protected void paintComponent(Graphics g) {
+ super.paintComponent(g);
+ if (getText().isEmpty() && !isFocused) {
+ Graphics2D g2 = (Graphics2D) g.create();
+ g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+ g2.setColor(new Color(170, 170, 170));
+ g2.setFont(getFont());
+ g2.drawString(text, 5, getHeight() / 2 + 6);
+ g2.dispose();
+ }
+ }
+ };
+ searchField.setFont(new Font("Segoe UI", Font.PLAIN, 18));
+ searchField.setBorder(new EmptyBorder(1, 8, 1, 8));
+ searchField.setOpaque(false);
+ searchField.setForeground(new Color(100, 100, 100));
+ searchField.setBackground(new Color(0, 0, 0, 0));
+
+ searchField.addFocusListener(new FocusAdapter() {
+ public void focusGained(FocusEvent e) {
+ isFocused = false;
+ container.repaint();
+ }
+
+ public void focusLost(FocusEvent e) {
+ isFocused = false;
+ container.repaint();
+ }
+ });
+
+ searchField.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ if (searchController != null) {
+ String query = searchField.getText().trim();
+ if (!query.isEmpty()) {
+ // Execute search with "name" as search type: currently has a default Location
+ searchController.execute(query, "name", location);
+ }
+ }
+ }
+ });
+
+ container.add(searchField, BorderLayout.CENTER);
+ return container;
+ }
+
+ public String getSearchText() {
+ return searchField.getText();
+ }
+
+ public void setSearchController(SearchController controller) {
+ this.searchController = controller;
+ }
+
+ public void setLocation(Location location) {
+ this.location = location;
+ }
+
+}
diff --git a/src/main/java/view/SearchEventByNameView.java b/src/main/java/view/SearchEventByNameView.java
new file mode 100644
index 00000000..70299566
--- /dev/null
+++ b/src/main/java/view/SearchEventByNameView.java
@@ -0,0 +1,233 @@
+package view;
+
+import javax.swing.*;
+
+import interface_adapter.ViewNames;
+import interface_adapter.save_event.SaveEventController;
+import interface_adapter.search_event_by_name.SearchEventByNameController;
+import interface_adapter.search_event_by_name.SearchEventByNameViewModel;
+import entity.Event;
+
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.net.URL;
+import java.time.format.DateTimeFormatter;
+
+public class SearchEventByNameView extends JPanel implements PropertyChangeListener {
+
+ private final String viewName = ViewNames.EVENT_SEARCH;
+ private final SearchEventByNameViewModel searchEventByNameViewModel;
+ private SearchEventByNameController eventController = null;
+
+ // Components that need to be updated
+ private JLabel categoryLabel;
+ private JLabel nameLabel;
+ private JLabel dateLabel;
+ private JLabel venueLabel;
+ private JTextArea descArea;
+ private JPanel imagePanel;
+ private SaveButtonView saveButtonView;
+ private SaveEventController saveEventController;
+
+ public SearchEventByNameView(SearchEventByNameViewModel searchEventByNameViewModel) {
+ this.searchEventByNameViewModel = searchEventByNameViewModel;
+ this.searchEventByNameViewModel.addPropertyChangeListener(this);
+ this.setLayout(new BorderLayout());
+
+ JPanel detailsPanel = createDetailsPanel();
+ add(detailsPanel, BorderLayout.CENTER);
+
+ imagePanel = createImagePanel();
+ imagePanel = createImagePanel();
+ add(imagePanel, BorderLayout.EAST);
+
+ // Initial update with current state
+ updateView();
+ }
+
+ private JPanel createDetailsPanel() {
+ JPanel mainPanel = new JPanel();
+ mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS));
+ mainPanel.setForeground(Color.WHITE);
+ mainPanel.setBorder(BorderFactory.createEmptyBorder(30, 30, 30, 30));
+ mainPanel.setPreferredSize(new Dimension(400, 700));
+
+ JButton backButton = new JButton("← Back to Events");
+ backButton.setFont(new Font("SegoeUI", Font.PLAIN, 13));
+ backButton.setAlignmentX(Component.LEFT_ALIGNMENT);
+ mainPanel.add(backButton);
+ mainPanel.add(Box.createVerticalStrut(24));
+
+ backButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ if (eventController != null) {
+ eventController.switchToDashboardView();
+ }
+ }
+ });
+
+ categoryLabel = new JLabel("Loading");
+ categoryLabel.setFont(new Font("SegoeUI", Font.BOLD, 11));
+ categoryLabel.setForeground(new Color(59, 130, 246));
+ categoryLabel.setOpaque(true);
+ categoryLabel.setBackground(new Color(219, 234, 254));
+ categoryLabel.setBorder(BorderFactory.createEmptyBorder(5, 12, 5, 12));
+ categoryLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+ mainPanel.add(categoryLabel);
+ mainPanel.add(Box.createVerticalStrut(12));
+
+ nameLabel = new JLabel("Loading Event...");
+ nameLabel.setFont(new Font("SegoeUI", Font.BOLD, 32));
+ nameLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+ mainPanel.add(nameLabel);
+ mainPanel.add(Box.createVerticalStrut(12));
+
+ JPanel dateRow = createRow("Date:", "");
+ dateLabel = (JLabel) dateRow.getComponent(1);
+ mainPanel.add(dateRow);
+ mainPanel.add(Box.createVerticalStrut(12));
+
+ JPanel venueRow = createRow("Venue:", "");
+ venueLabel = (JLabel) venueRow.getComponent(1);
+ mainPanel.add(venueRow);
+ mainPanel.add(Box.createVerticalStrut(12));
+
+ JLabel descTitle = new JLabel("About this event");
+ descTitle.setFont(new Font("SegoeUI", Font.BOLD, 16));
+ descTitle.setForeground(new Color(20, 20, 20));
+ descTitle.setAlignmentX(Component.LEFT_ALIGNMENT);
+ mainPanel.add(descTitle);
+ mainPanel.add(Box.createVerticalStrut(12));
+
+ descArea = new JTextArea("Loading description...");
+ descArea.setFont(new Font("SegoeUI", Font.PLAIN, 14));
+ descArea.setForeground(new Color(80, 80, 80));
+ descArea.setBackground(Color.WHITE);
+ descArea.setLineWrap(true);
+ descArea.setWrapStyleWord(true);
+ descArea.setEditable(false);
+ descArea.setBorder(null);
+ descArea.setAlignmentX(Component.LEFT_ALIGNMENT);
+ mainPanel.add(descArea);
+ mainPanel.add(Box.createVerticalStrut(30));
+
+ saveButtonView = new SaveButtonView();
+ saveButtonView.setAlignmentX(Component.LEFT_ALIGNMENT);
+ mainPanel.add(saveButtonView);
+
+ JScrollPane scrollPane = new JScrollPane(mainPanel);
+ scrollPane.setBorder(null);
+ scrollPane.getVerticalScrollBar().setUnitIncrement(16);
+
+ JPanel wrapper = new JPanel(new BorderLayout());
+ wrapper.add(scrollPane);
+
+ return wrapper;
+ }
+
+ private JPanel createImagePanel() {
+ JPanel mainPanel = new JPanel(new BorderLayout());
+ mainPanel.setPreferredSize(new Dimension(500, 700));
+ mainPanel.setBackground(new Color(30, 30, 30));
+
+ JLabel placeholderLabel = new JLabel("Loading", SwingConstants.CENTER);
+ placeholderLabel.setForeground(Color.WHITE);
+ mainPanel.add(placeholderLabel, BorderLayout.CENTER);
+
+ return mainPanel;
+ }
+
+ private void updateImagePanel(String imageUrl) {
+ imagePanel.removeAll();
+
+ try {
+ URL url = new URL(imageUrl);
+ ImageIcon icon = new ImageIcon(url);
+ Image image = icon.getImage().getScaledInstance(500, 700, Image.SCALE_SMOOTH);
+ JLabel imageLabel = new JLabel(new ImageIcon(image));
+ imagePanel.add(imageLabel, BorderLayout.CENTER);
+ } catch (Exception e) {
+ JLabel placeholderLabel = new JLabel("No Image Available", SwingConstants.CENTER);
+ placeholderLabel.setForeground(Color.WHITE);
+ imagePanel.add(placeholderLabel, BorderLayout.CENTER);
+ }
+
+ imagePanel.revalidate();
+ imagePanel.repaint();
+ }
+
+ private JPanel createRow(String category, String text) {
+ JPanel row = new JPanel(new FlowLayout(FlowLayout.LEFT, 8, 0));
+ row.setOpaque(false);
+ row.setAlignmentX(Component.LEFT_ALIGNMENT);
+ row.setMaximumSize(new Dimension(400, 30));
+
+ JLabel title = new JLabel(category);
+ title.setFont(new Font("SegoeUI", Font.BOLD, 14));
+ title.setForeground(new Color(50, 50, 50));
+
+ JLabel description = new JLabel(text);
+ description.setFont(new Font("SegoeUI", Font.PLAIN, 14));
+ description.setForeground(new Color(50, 50, 50));
+
+ row.add(title);
+ row.add(description);
+
+ return row;
+ }
+
+ @Override
+ public void propertyChange(PropertyChangeEvent evt) {
+ updateView();
+ }
+
+ private void updateView() {
+ Event event = searchEventByNameViewModel.getEvent();
+
+ if (event != null) {
+ categoryLabel.setText(event.getCategory().getDisplayName());
+
+ nameLabel.setText("" + event.getName().replace(" ", "
") + "");
+
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM dd, yyyy");
+ dateLabel.setText(event.getStartTime().format(formatter));
+
+
+ String venueText = event.getLocation().getAddress();
+ if (venueText.length() > 50) {
+ venueText = venueText.substring(0, 47) + "...";
+ }
+ venueLabel.setText(venueText);
+
+ String desc = event.getDescription();
+ descArea.setText(desc.isEmpty() ? "No description available" : desc);
+
+ updateImagePanel(event.getImageUrl());
+
+ saveButtonView.setEvent(event);
+ saveButtonView.setSaveEventController(saveEventController);
+
+ }
+ }
+
+ public String getViewName() {
+ return viewName;
+ }
+
+
+
+ public void setEventController(SearchEventByNameController controller) {
+ this.eventController = controller;
+ }
+
+ public void setSaveButtonController(SaveEventController eventController) {
+ this.saveButtonView.setSaveEventController(eventController);
+ this.saveEventController = eventController;
+ }
+
+}
+
diff --git a/src/main/java/view/SignupView.java b/src/main/java/view/SignupView.java
index 1330c097..06274cf4 100644
--- a/src/main/java/view/SignupView.java
+++ b/src/main/java/view/SignupView.java
@@ -1,5 +1,6 @@
package view;
+import interface_adapter.ViewNames;
import interface_adapter.signup.SignupController;
import interface_adapter.signup.SignupState;
import interface_adapter.signup.SignupViewModel;
@@ -10,6 +11,10 @@
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
@@ -17,7 +22,7 @@
* The View for the Signup Use Case.
*/
public class SignupView extends JPanel implements ActionListener, PropertyChangeListener {
- private final String viewName = "sign up";
+ private final String viewName = ViewNames.SIGNUP;
private final SignupViewModel signupViewModel;
private final JTextField usernameInputField = new JTextField(15);
@@ -26,15 +31,26 @@ public class SignupView extends JPanel implements ActionListener, PropertyChange
private SignupController signupController = null;
private final JButton signUp;
- private final JButton cancel;
private final JButton toLogin;
public SignupView(SignupViewModel signupViewModel) {
this.signupViewModel = signupViewModel;
signupViewModel.addPropertyChangeListener(this);
+ JPanel leftPanel = brandPanel();
+ JPanel rightPanel = new JPanel();
+ rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.Y_AXIS));
+ rightPanel.setBorder(BorderFactory.createEmptyBorder(100, 0, 0, 0));
+
+
final JLabel title = new JLabel(SignupViewModel.TITLE_LABEL);
title.setAlignmentX(Component.CENTER_ALIGNMENT);
+ title.setFont(new Font("SegoeUI", Font.BOLD, 36));
+
+ JLabel subtitleLabel = new JLabel(SignupViewModel.TITLE_CAPTION);
+ subtitleLabel.setFont(new Font("SegoeUI", Font.PLAIN, 14));
+ subtitleLabel.setForeground(new Color(107, 114, 128));
+ subtitleLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
final LabelTextPanel usernameInfo = new LabelTextPanel(
new JLabel(SignupViewModel.USERNAME_LABEL), usernameInputField);
@@ -48,8 +64,9 @@ public SignupView(SignupViewModel signupViewModel) {
buttons.add(toLogin);
signUp = new JButton(SignupViewModel.SIGNUP_BUTTON_LABEL);
buttons.add(signUp);
- cancel = new JButton(SignupViewModel.CANCEL_BUTTON_LABEL);
- buttons.add(cancel);
+
+ styleButton(signUp, new Color(0, 0, 0));
+ styleButton(toLogin, new Color(0, 0, 0));
signUp.addActionListener(
// This creates an anonymous subclass of ActionListener and instantiates it.
@@ -76,19 +93,107 @@ public void actionPerformed(ActionEvent evt) {
}
);
- cancel.addActionListener(this);
-
addUsernameListener();
addPasswordListener();
addRepeatPasswordListener();
- this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
+ this.setLayout(new GridLayout(1, 2));
+
+ JPanel titlePanel = new JPanel();
+ titlePanel.setLayout(new BoxLayout(titlePanel, BoxLayout.Y_AXIS));
+ titlePanel.setOpaque(false);
+ titlePanel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ titlePanel.add(title);
+ titlePanel.add(Box.createRigidArea(new Dimension(0, 10)));
+ titlePanel.add(subtitleLabel);
+
+ JPanel formPanel = new JPanel();
+ formPanel.setLayout(new BoxLayout(formPanel, BoxLayout.Y_AXIS));
+ formPanel.setOpaque(false);
+ formPanel.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ formPanel.add(usernameInfo);
+ formPanel.add(Box.createRigidArea(new Dimension(0, 20)));
+
+ formPanel.add(passwordInfo);
+ formPanel.add(Box.createRigidArea(new Dimension(0, 20)));
+
+ formPanel.add(repeatPasswordInfo);
+
+ rightPanel.add(titlePanel);
+ rightPanel.add(Box.createRigidArea(new Dimension(0, 20)));
+ rightPanel.add(formPanel);
+ rightPanel.add(Box.createRigidArea(new Dimension(0, 20)));
+ rightPanel.add(buttons);
+
+ leftPanel.setPreferredSize(new Dimension(400, 600));
+ rightPanel.setPreferredSize(new Dimension(400, 600));
+
+
+ this.add(leftPanel);
+ this.add(rightPanel);
+ }
+
+ /**
+ *
+ * @return a custom JPanel for the left side of the sign up view
+ * Written with the help of Generative AI
+ */
+ private JPanel brandPanel() {
+ JPanel panel = new JPanel() {
+ @Override
+ protected void paintComponent(Graphics g) {
+ super.paintComponent(g);
+ // Extension of the Graphics class to allow for gradients
+ Graphics2D g2d = (Graphics2D) g;
+ g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+ // Create gradient
+ GradientPaint gradient = new GradientPaint(
+ 0, 0, new Color(10, 103, 198),
+ getWidth(), getHeight(), new Color(13, 133, 251)
+ );
+ g2d.setPaint(gradient);
+ g2d.fillRect(0, 0, getWidth(), getHeight());
+
+ // Draw decorative circles
+ g2d.setColor(new Color(255, 255, 255, 30));
+ g2d.fillOval(-50, -50, 200, 200);
+ g2d.fillOval(getWidth() - 150, getHeight() - 150, 200, 200);
+ }
+ };
+ panel.setLayout(new GridBagLayout());
+
+ JPanel content = new JPanel();
+ content.setOpaque(false);
+ content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
+
+ JLabel title = new JLabel(SignupViewModel.TITLE);
+ title.setFont(new Font("Segoe UI", Font.BOLD, 36));
+ title.setForeground(Color.WHITE);
+ title.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ JLabel subtitle = new JLabel(SignupViewModel.CAPTION);
+ subtitle.setFont(new Font("Segoe UI", Font.PLAIN, 16));
+ subtitle.setForeground(new Color(255, 255, 255, 200));
+ subtitle.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ content.add(title);
+ content.add(Box.createRigidArea(new Dimension(0, 10)));
+ content.add(subtitle);
+
+ panel.add(content);
+ return panel;
+ }
- this.add(title);
- this.add(usernameInfo);
- this.add(passwordInfo);
- this.add(repeatPasswordInfo);
- this.add(buttons);
+ private void styleButton(JButton button, Color color) {
+ button.setFont(new Font("SegoeUI", Font.BOLD, 14));
+ button.setForeground(Color.BLUE);
+ button.setBackground(color);
+ button.setFocusPainted(false);
+ button.setBorderPainted(false);
+ button.setCursor(new Cursor(Cursor.HAND_CURSOR));
}
private void addUsernameListener() {
diff --git a/src/main/resources/images/concert.jpg b/src/main/resources/images/concert.jpg
new file mode 100644
index 00000000..e13896df
Binary files /dev/null and b/src/main/resources/images/concert.jpg differ
diff --git a/src/main/resources/images/placeholder.jpg b/src/main/resources/images/placeholder.jpg
new file mode 100644
index 00000000..c44ebc89
Binary files /dev/null and b/src/main/resources/images/placeholder.jpg differ
diff --git a/src/test/java/data_access/data_access.java b/src/test/java/data_access/data_access.java
new file mode 100644
index 00000000..0601c78f
--- /dev/null
+++ b/src/test/java/data_access/data_access.java
@@ -0,0 +1,47 @@
+package data_access;
+
+import entity.Event;
+import entity.Location;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class InMemoryEventDataAccessObjectTest {
+
+ @Test
+ void saveAndGetEvent() {
+ EventDataAccessInterface eventDAO = new InMemoryEventDataAccessObject();
+
+ Location loc = new Location(43.0, -79.0);
+ Event event = new Event(
+ "1",
+ "Music Festival",
+ "Outdoor live music event",
+ "123 Queen St",
+ loc,
+ "Music",
+ "2025-11-20T19:00"
+ );
+
+ eventDAO.save(event);
+ Event retrieved = eventDAO.get("1");
+
+ assertTrue(eventDAO.existsById("1"));
+ assertNotNull(retrieved);
+ assertEquals("Music Festival", retrieved.getName());
+ assertEquals("123 Queen St", retrieved.getAddress());
+ assertEquals(43.0, retrieved.getLocation().getLatitude(), 1e-6);
+ assertEquals(-79.0, retrieved.getLocation().getLongitude(), 1e-6);
+ }
+
+ @Test
+ void eventDoesNotExist() {
+ EventDataAccessInterface eventDAO = new InMemoryEventDataAccessObject();
+
+ boolean exists = eventDAO.existsById("999");
+ Event retrieved = eventDAO.get("999");
+
+ assertFalse(exists);
+ assertNull(retrieved);
+ }
+}
diff --git a/src/test/java/demo/NoDataAccessEventViewDemo.java b/src/test/java/demo/NoDataAccessEventViewDemo.java
new file mode 100644
index 00000000..9202292e
--- /dev/null
+++ b/src/test/java/demo/NoDataAccessEventViewDemo.java
@@ -0,0 +1,91 @@
+package demo;
+
+import interface_adapter.login.LoginViewModel;
+import use_case.search_event_by_name.SearchEventByNameDataAccessInterface;
+import entity.Event;
+import entity.Location;
+import interface_adapter.ViewManagerModel;
+import interface_adapter.search_event_by_name.SearchEventByNameController;
+import interface_adapter.search_event_by_name.SearchEventByNamePresenter;
+import interface_adapter.search_event_by_name.SearchEventByNameViewModel;
+import use_case.search_event_by_name.SearchEventByNameInputBoundary;
+import use_case.search_event_by_name.SearchEventByNameInteractor;
+import use_case.search_event_by_name.SearchEventByNameOutputBoundary;
+import view.SearchEventByNameView;
+
+import javax.swing.*;
+import java.awt.*;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.ArrayList;
+import java.util.List;
+
+public class NoDataAccessEventViewDemo {
+ public static void main(String[] args) {
+ JFrame frame = new JFrame("Event View Test");
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ frame.setLayout(new CardLayout());
+
+ final ViewManagerModel viewManagerModel = new ViewManagerModel();
+ final LoginViewModel loginViewModel = new LoginViewModel();
+
+ // Create a simple login view for testing
+ JPanel loginView = new JPanel();
+ loginView.setBackground(Color.BLUE);
+ loginView.add(new JLabel("Login View - Back button worked!"));
+
+ // Create mock data access
+ SearchEventByNameDataAccessInterface mockDataAccess = new SearchEventByNameDataAccessInterface() {
+ @Override
+ public List searchEventsByName(String keyword, Location location, double radiusKm) {
+ return new ArrayList<>();
+ }
+
+
+ public Event getEventByName(String eventName) {
+ return null;
+ }
+
+
+ public List searchEvents(String query) {
+ return new ArrayList<>();
+ }
+ };
+
+ // Create the search event view
+ final SearchEventByNameViewModel viewModel = new SearchEventByNameViewModel();
+ final SearchEventByNameOutputBoundary outputBoundary = new SearchEventByNamePresenter(viewModel, viewManagerModel);
+ final SearchEventByNameInputBoundary inputBoundary = new SearchEventByNameInteractor(mockDataAccess, outputBoundary);
+ final SearchEventByNameController eventController = new SearchEventByNameController(inputBoundary);
+
+ SearchEventByNameView eventView = new SearchEventByNameView(viewModel);
+ eventView.setEventController(eventController);
+
+ // Add both views to the frame with CardLayout
+ frame.add(eventView, "eventView");
+ frame.add(loginView, "loginView");
+
+ // Set up ViewManagerModel listener to switch views
+ viewManagerModel.addPropertyChangeListener(new PropertyChangeListener() {
+ @Override
+ public void propertyChange(PropertyChangeEvent evt) {
+ if ("state".equals(evt.getPropertyName())) {
+ CardLayout cardLayout = (CardLayout) frame.getContentPane().getLayout();
+ String newView = (String) evt.getNewValue();
+ cardLayout.show(frame.getContentPane(), newView);
+ frame.revalidate();
+ frame.repaint();
+ }
+ }
+ });
+
+ // Set initial view
+ viewManagerModel.setState("");
+ viewManagerModel.firePropertyChange();
+
+ frame.setSize(900, 700);
+ frame.setLocationRelativeTo(null);
+ frame.setVisible(true);
+
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/demo/SaveButtonViewDemo.java b/src/test/java/demo/SaveButtonViewDemo.java
new file mode 100644
index 00000000..d69186f5
--- /dev/null
+++ b/src/test/java/demo/SaveButtonViewDemo.java
@@ -0,0 +1,18 @@
+package demo;
+
+import view.SaveButtonView;
+
+import javax.swing.*;
+
+public class SaveButtonViewDemo {
+ public static void main(String[] args) {
+ SwingUtilities.invokeLater(() -> {
+ JFrame frame = new JFrame("SaveButtonView Demo");
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ frame.add(new SaveButtonView());
+ frame.pack();
+ frame.setLocationRelativeTo(null);
+ frame.setVisible(true);
+ });
+ }
+}
diff --git a/src/test/java/demo/SaveEventViewDemo.java b/src/test/java/demo/SaveEventViewDemo.java
new file mode 100644
index 00000000..ce000a80
--- /dev/null
+++ b/src/test/java/demo/SaveEventViewDemo.java
@@ -0,0 +1,327 @@
+package demo;
+
+import data_access.FileSavedEventsDataAccessObject;
+import entity.Event;
+import entity.EventCategory;
+import entity.Location;
+import interface_adapter.ViewManagerModel;
+import interface_adapter.save_event.SaveEventController;
+import interface_adapter.save_event.SaveEventPresenter;
+import interface_adapter.save_event.SaveEventViewModel;
+import use_case.login.LoginUserDataAccessInterface;
+import use_case.save_event.SaveEventInteractor;
+import view.SaveButtonView;
+import view.SaveEventsView;
+
+import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+import java.awt.*;
+import java.time.LocalDateTime;
+
+/**
+ * Visual demo to test the SaveButtonView and SaveEventsView integration with file persistence
+ * Run this to see the complete save event workflow with data persistence
+ * WRITTEN BY GENAI for DEMO purposes only
+ */
+public class SaveEventViewDemo {
+
+ public static void main(String[] args) {
+ SwingUtilities.invokeLater(() -> {
+ // Create the main frame
+ JFrame frame = new JFrame("Save Event Feature Demo (With Persistence!)");
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ frame.setSize(1200, 800);
+ frame.setLocationRelativeTo(null);
+
+ // Create a mock user data access with a demo user
+ MockUserDataAccess userDataAccess = new MockUserDataAccess();
+ userDataAccess.setCurrentUsername("demo_user"); // Fallback user for demo
+
+ // Create the file-based saved events DAO
+ FileSavedEventsDataAccessObject savedEventsDAO = new FileSavedEventsDataAccessObject();
+
+ // Set up the architecture components
+ SaveEventViewModel saveEventViewModel = new SaveEventViewModel();
+ ViewManagerModel viewManagerModel = new ViewManagerModel();
+ SaveEventPresenter presenter = new SaveEventPresenter(saveEventViewModel, viewManagerModel);
+ SaveEventInteractor interactor = new SaveEventInteractor(presenter, savedEventsDAO, userDataAccess);
+ SaveEventController controller = new SaveEventController(interactor);
+
+ // Create views
+ SaveEventsView saveEventsView = new SaveEventsView(saveEventViewModel);
+ saveEventsView.setSaveEventInteractor(interactor);
+ saveEventsView.setSaveEventController(controller);
+
+ // Create main panel with CardLayout for switching views
+ CardLayout cardLayout = new CardLayout();
+ JPanel mainPanel = new JPanel(cardLayout);
+
+ // Create the event browsing panel
+ JPanel browsePanel = createBrowsePanel(controller, cardLayout, mainPanel, saveEventsView);
+
+ // Add panels to card layout
+ mainPanel.add(browsePanel, "browse");
+ mainPanel.add(saveEventsView, "saved");
+
+ viewManagerModel.addPropertyChangeListener(evt -> {
+ if ("state".equals(evt.getPropertyName())) {
+ cardLayout.show(mainPanel, "browse");
+ }
+ });
+
+ frame.add(mainPanel);
+ frame.setVisible(true);
+ });
+ }
+
+ private static JPanel createBrowsePanel(SaveEventController controller,
+ CardLayout cardLayout,
+ JPanel mainPanel,
+ SaveEventsView saveEventsView) {
+ JPanel panel = new JPanel(new BorderLayout());
+ panel.setBackground(new Color(249, 250, 251));
+
+ // Header
+ JPanel header = new JPanel(new BorderLayout());
+ header.setBackground(Color.WHITE);
+ header.setBorder(new EmptyBorder(20, 40, 20, 40));
+
+ JLabel title = new JLabel("Browse Events (demo_user)");
+ title.setFont(new Font("Segoe UI", Font.BOLD, 28));
+ title.setForeground(new Color(17, 24, 39));
+
+ JButton viewSavedButton = new JButton("View My Saved Events →");
+ viewSavedButton.setFont(new Font("Segoe UI", Font.BOLD, 14));
+ viewSavedButton.setForeground(new Color(59, 130, 246));
+ viewSavedButton.setBackground(Color.WHITE);
+ viewSavedButton.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createLineBorder(new Color(59, 130, 246), 2),
+ BorderFactory.createEmptyBorder(10, 20, 10, 20)
+ ));
+ viewSavedButton.setFocusPainted(false);
+ viewSavedButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
+
+ viewSavedButton.addActionListener(e -> {
+// saveEventsView.refreshEventsList();
+ cardLayout.show(mainPanel, "saved");
+ });
+
+ header.add(title, BorderLayout.WEST);
+ header.add(viewSavedButton, BorderLayout.EAST);
+
+ // Events container
+ JPanel eventsContainer = new JPanel();
+ eventsContainer.setLayout(new BoxLayout(eventsContainer, BoxLayout.Y_AXIS));
+ eventsContainer.setBackground(new Color(249, 250, 251));
+ eventsContainer.setBorder(new EmptyBorder(20, 40, 20, 40));
+
+ // Add sample events
+ eventsContainer.add(createEventCard(createSampleEvent1(), controller));
+ eventsContainer.add(Box.createVerticalStrut(20));
+// eventsContainer.add(createEventCard(createSampleEvent2(), controller));
+// eventsContainer.add(Box.createVerticalStrut(20));
+// eventsContainer.add(createEventCard(createSampleEvent3(), controller));
+// eventsContainer.add(Box.createVerticalStrut(20));
+// eventsContainer.add(createEventCard(createSampleEvent4(), controller));
+// eventsContainer.add(Box.createVerticalStrut(20));
+// eventsContainer.add(createEventCard(createSampleEvent5(), controller));
+
+ JScrollPane scrollPane = new JScrollPane(eventsContainer);
+ scrollPane.setBorder(null);
+ scrollPane.getVerticalScrollBar().setUnitIncrement(16);
+
+ panel.add(header, BorderLayout.NORTH);
+ panel.add(scrollPane, BorderLayout.CENTER);
+
+ return panel;
+ }
+
+ private static JPanel createEventCard(Event event, SaveEventController controller) {
+ JPanel card = new JPanel(new BorderLayout(20, 0));
+ card.setBackground(Color.WHITE);
+ card.setBorder(BorderFactory.createCompoundBorder(
+ BorderFactory.createLineBorder(new Color(229, 231, 235), 1),
+ BorderFactory.createEmptyBorder(20, 20, 20, 20)
+ ));
+ card.setMaximumSize(new Dimension(Integer.MAX_VALUE, 180));
+
+ // Image placeholder
+ JPanel imagePanel = createImagePanel(event.getCategory());
+ imagePanel.setPreferredSize(new Dimension(140, 140));
+
+ // Details panel
+ JPanel detailsPanel = new JPanel();
+ detailsPanel.setLayout(new BoxLayout(detailsPanel, BoxLayout.Y_AXIS));
+ detailsPanel.setOpaque(false);
+
+ // Category badge
+ JLabel categoryLabel = new JLabel(event.getCategory().toString());
+ categoryLabel.setFont(new Font("Segoe UI", Font.BOLD, 11));
+ Color categoryColor = getCategoryColor(event.getCategory());
+ categoryLabel.setForeground(categoryColor);
+ categoryLabel.setOpaque(true);
+ categoryLabel.setBackground(new Color(categoryColor.getRed(),
+ categoryColor.getGreen(), categoryColor.getBlue(), 40));
+ categoryLabel.setBorder(BorderFactory.createEmptyBorder(4, 10, 4, 10));
+ categoryLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ // Event name
+ JLabel nameLabel = new JLabel(event.getName());
+ nameLabel.setFont(new Font("Segoe UI", Font.BOLD, 20));
+ nameLabel.setForeground(new Color(17, 24, 39));
+ nameLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ // Description
+ JLabel descLabel = new JLabel("" + truncateText(event.getDescription(), 100) + "");
+ descLabel.setFont(new Font("Segoe UI", Font.PLAIN, 14));
+ descLabel.setForeground(new Color(107, 114, 128));
+ descLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ // Date
+ JLabel dateLabel = new JLabel("📅 " + formatDate(event.getStartTime()));
+ dateLabel.setFont(new Font("Segoe UI", Font.PLAIN, 13));
+ dateLabel.setForeground(new Color(107, 114, 128));
+ dateLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ // Location
+ JLabel locationLabel = new JLabel("📍 " + event.getLocation().getAddress());
+ locationLabel.setFont(new Font("Segoe UI", Font.PLAIN, 13));
+ locationLabel.setForeground(new Color(107, 114, 128));
+ locationLabel.setAlignmentX(Component.LEFT_ALIGNMENT);
+
+ detailsPanel.add(categoryLabel);
+ detailsPanel.add(Box.createVerticalStrut(10));
+ detailsPanel.add(nameLabel);
+ detailsPanel.add(Box.createVerticalStrut(8));
+ detailsPanel.add(descLabel);
+ detailsPanel.add(Box.createVerticalStrut(10));
+ detailsPanel.add(dateLabel);
+ detailsPanel.add(Box.createVerticalStrut(5));
+ detailsPanel.add(locationLabel);
+
+ // Save button
+ SaveButtonView saveButtonView = new SaveButtonView();
+ saveButtonView.setSaveEventController(controller);
+ saveButtonView.setEvent(event);
+ saveButtonView.setOpaque(false);
+
+ card.add(imagePanel, BorderLayout.WEST);
+ card.add(detailsPanel, BorderLayout.CENTER);
+ card.add(saveButtonView, BorderLayout.EAST);
+
+ return card;
+ }
+
+ private static JPanel createImagePanel(EventCategory category) {
+ return new JPanel() {
+ @Override
+ protected void paintComponent(Graphics g) {
+ super.paintComponent(g);
+ Graphics2D g2 = (Graphics2D) g;
+ g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+ Color categoryColor = getCategoryColor(category);
+ GradientPaint gradient = new GradientPaint(
+ 0, 0, categoryColor.darker(),
+ getWidth(), getHeight(), categoryColor
+ );
+ g2.setPaint(gradient);
+ g2.fillRoundRect(0, 0, getWidth(), getHeight(), 15, 15);
+
+ // Draw icon
+ g2.setColor(Color.WHITE);
+ g2.setFont(new Font("Segoe UI", Font.BOLD, 48));
+ String icon = getIconForCategory(category);
+ FontMetrics fm = g2.getFontMetrics();
+ int x = (getWidth() - fm.stringWidth(icon)) / 2;
+ int y = (getHeight() + fm.getAscent()) / 2 - 5;
+ g2.drawString(icon, x, y);
+ }
+ };
+ }
+
+ private static String getIconForCategory(EventCategory category) {
+ switch (category) {
+ case MUSIC: return "♪";
+ case SPORTS: return "⚽";
+ case ARTS_THEATRE: return "🎭";
+ case FILM: return "🎬";
+ default: return "★";
+ }
+ }
+
+ private static Color getCategoryColor(EventCategory category) {
+ switch (category) {
+ case MUSIC:
+ return new Color(147, 51, 234); // Purple
+ case SPORTS:
+ return new Color(59, 130, 246); // Blue
+ case ARTS_THEATRE:
+ return new Color(236, 72, 153); // Pink
+ case FILM:
+ return new Color(245, 158, 11); // Orange
+ default:
+ return new Color(107, 114, 128); // Gray
+ }
+ }
+
+ private static String truncateText(String text, int maxLength) {
+ if (text == null) return "";
+ if (text.length() <= maxLength) return text;
+ return text.substring(0, maxLength) + "...";
+ }
+
+ private static String formatDate(LocalDateTime dateTime) {
+ String[] months = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+ return months[dateTime.getMonthValue() - 1] + " " +
+ dateTime.getDayOfMonth() + ", " +
+ dateTime.getYear() + " at " +
+ String.format("%02d:%02d", dateTime.getHour(), dateTime.getMinute());
+ }
+
+ // Sample Events
+ private static Event createSampleEvent1() {
+ Location location = new Location("Scotiabank Arena, 40 Bay St, Toronto, ON", 43.6435, -79.3791);
+ return new Event(
+ "event-1",
+ "Toronto Raptors vs Los Angeles Lakers",
+ "An epic showdown between two NBA powerhouses. Watch the Raptors take on LeBron James and the Lakers in what promises to be an unforgettable night of basketball action!",
+ location.getAddress(),
+ EventCategory.SPORTS,
+ location,
+ LocalDateTime.of(2025, 12, 15, 19, 30),
+ "https://via.placeholder.com/500x700"
+ );
+ }
+
+ // Mock User Data Access for demo purposes
+ private static class MockUserDataAccess implements LoginUserDataAccessInterface {
+ private String currentUsername;
+
+ @Override
+ public boolean existsByName(String identifier) {
+ return "demo_user".equals(identifier);
+ }
+
+ @Override
+ public void save(entity.User user) {
+ // Not needed for demo
+ }
+
+ @Override
+ public entity.User get(String username) {
+ return null; // Not needed for demo
+ }
+
+ @Override
+ public void setCurrentUsername(String name) {
+ this.currentUsername = name;
+ }
+
+ @Override
+ public String getCurrentUsername() {
+ return currentUsername;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/demo/SearchToEventViewDemo.java b/src/test/java/demo/SearchToEventViewDemo.java
new file mode 100644
index 00000000..52f6136c
--- /dev/null
+++ b/src/test/java/demo/SearchToEventViewDemo.java
@@ -0,0 +1,153 @@
+package demo;
+
+import data_access.EventDataAccessObject;
+import entity.Event;
+import entity.Location;
+import interface_adapter.ViewManagerModel;
+import interface_adapter.search.SearchController;
+import interface_adapter.search.SearchPresenter;
+import interface_adapter.search_event_by_name.SearchEventByNameController;
+import interface_adapter.search_event_by_name.SearchEventByNamePresenter;
+import interface_adapter.search_event_by_name.SearchEventByNameViewModel;
+import use_case.search.SearchInputBoundary;
+import use_case.search.SearchInteractor;
+import use_case.search.SearchOutputBoundary;
+import use_case.search_event_by_name.SearchEventByNameDataAccessInterface;
+import use_case.search_event_by_name.SearchEventByNameInputBoundary;
+import use_case.search_event_by_name.SearchEventByNameInteractor;
+import use_case.search_event_by_name.SearchEventByNameOutputBoundary;
+import view.SearchBarView;
+import view.SearchEventByNameView;
+import view.ViewManager;
+
+import javax.swing.*;
+import java.awt.*;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.List;
+
+/**
+ * Test application that demonstrates search bar -> event view flow
+ */
+public class SearchToEventViewDemo {
+
+ public static void main(String[] args) {
+ SwingUtilities.invokeLater(() -> {
+ JFrame frame = new JFrame("Event Search Test");
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ frame.setSize(1100, 750);
+
+ // Creates the cardLayout
+ CardLayout cardLayout = new CardLayout();
+ JPanel cardPanel = new JPanel(cardLayout);
+ ViewManagerModel viewManagerModel = new ViewManagerModel();
+ ViewManager viewManager = new ViewManager(cardPanel, cardLayout, viewManagerModel);
+ SearchEventByNameDataAccessInterface dataAccess = new SearchEventByNameDataAccessObject();
+ SearchEventByNameViewModel searchEventViewModel = new SearchEventByNameViewModel();
+ SearchEventByNameView eventView = new SearchEventByNameView(searchEventViewModel);
+
+ SearchOutputBoundary searchPresenter = new SearchPresenter(
+ searchEventViewModel,
+ viewManagerModel
+ );
+
+ SearchInputBoundary searchInteractor = new SearchInteractor(
+ dataAccess,
+ searchPresenter
+ );
+
+ SearchController searchController = new SearchController(searchInteractor);
+
+ SearchEventByNameOutputBoundary eventPresenter = new SearchEventByNamePresenter(
+ searchEventViewModel,
+ viewManagerModel
+ );
+
+ SearchEventByNameInputBoundary eventInteractor = new SearchEventByNameInteractor(
+ dataAccess,
+ eventPresenter
+ );
+
+ SearchEventByNameController eventController = new SearchEventByNameController(eventInteractor);
+ eventView.setEventController(eventController);
+
+ JPanel searchPanel = createSearchView(searchController);
+
+ cardPanel.add(searchPanel, "search");
+ cardPanel.add(eventView, eventView.getViewName());
+
+ viewManagerModel.addPropertyChangeListener(new PropertyChangeListener() {
+ @Override
+ public void propertyChange(PropertyChangeEvent evt) {
+ if (evt.getPropertyName().equals("state")) {
+ String viewName = (String) evt.getNewValue();
+ cardLayout.show(cardPanel, viewName);
+ }
+ }
+ });
+
+ viewManagerModel.setState("search");
+ viewManagerModel.firePropertyChange();
+
+ frame.add(cardPanel);
+ frame.setLocationRelativeTo(null);
+ frame.setVisible(true);
+
+ System.out.println("Application started! YIPPEE");
+ });
+ }
+
+ /**
+ * Creates a simple search view with a search bar
+ */
+ private static JPanel createSearchView(SearchController searchController) {
+ JPanel panel = new JPanel(new BorderLayout());
+ panel.setBackground(Color.WHITE);
+
+ // Title
+ JLabel titleLabel = new JLabel("Event Search", SwingConstants.CENTER);
+ titleLabel.setFont(new Font("SansSerif", Font.BOLD, 36));
+ titleLabel.setBorder(BorderFactory.createEmptyBorder(50, 0, 30, 0));
+
+ // Search bar with FIXED dimensions
+ SearchBarView searchBar = new SearchBarView("Search for events...", new Location("Milwaukee, WI", 43.0389, -87.9065));
+ searchBar.setSearchController(searchController);
+ searchBar.setMinimumSize(new Dimension(600, 60));
+ searchBar.setMaximumSize(new Dimension(600, 60));
+ searchBar.setPreferredSize(new Dimension(600, 60));
+
+ // Center panel - use FlowLayout to respect fixed sizes
+ JPanel centerPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
+ centerPanel.setBackground(Color.WHITE);
+
+ JPanel verticalWrapper = new JPanel();
+ verticalWrapper.setLayout(new BoxLayout(verticalWrapper, BoxLayout.Y_AXIS));
+ verticalWrapper.setBackground(Color.WHITE);
+ verticalWrapper.add(searchBar);
+ verticalWrapper.add(Box.createVerticalStrut(10));
+
+ centerPanel.add(verticalWrapper);
+
+ // Add components to main panel
+ panel.add(titleLabel, BorderLayout.NORTH);
+ panel.add(centerPanel, BorderLayout.CENTER);
+
+ return panel;
+ }
+
+ /**
+ * Implementation of the data access interface that uses EventDataAccessObject
+ */
+ private static class SearchEventByNameDataAccessObject implements SearchEventByNameDataAccessInterface {
+ private final EventDataAccessObject eventDAO;
+
+ public SearchEventByNameDataAccessObject() {
+ this.eventDAO = new EventDataAccessObject();
+ }
+
+ @Override
+ public List searchEventsByName(String keyword, Location location, double radiusKm) {
+ return eventDAO.searchEventsByName(keyword, location, radiusKm);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/demo/SimpleSearchBarDemo.java b/src/test/java/demo/SimpleSearchBarDemo.java
new file mode 100644
index 00000000..53a0cd38
--- /dev/null
+++ b/src/test/java/demo/SimpleSearchBarDemo.java
@@ -0,0 +1,26 @@
+package demo;
+
+
+import entity.Location;
+import view.SearchBarView;
+import javax.swing.*;
+
+public class SimpleSearchBarDemo {
+ public static void main(String[] args) {
+ JFrame frame = new JFrame("Simple Search Bar Demo");
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ frame.setSize(700, 200);
+ frame.setLocationRelativeTo(null);
+
+ // Create main panel
+ JPanel mainPanel = new JPanel();
+ mainPanel.setBorder(BorderFactory.createEmptyBorder(50, 50, 50, 50));
+
+ // Create and add your search bar
+ SearchBarView searchBar = new SearchBarView("Hello!", new Location("Milwaukee, WI", 43.0389, -87.9065));
+ mainPanel.add(searchBar);
+
+ frame.add(mainPanel);
+ frame.setVisible(true);
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/entity/EventTest.java b/src/test/java/entity/EventTest.java
new file mode 100644
index 00000000..2d41f75e
--- /dev/null
+++ b/src/test/java/entity/EventTest.java
@@ -0,0 +1,820 @@
+package entity;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.BeforeEach;
+
+import java.time.LocalDateTime;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class EventTest {
+
+ private Location defaultLocation;
+ private LocalDateTime defaultDateTime;
+
+ @BeforeEach
+ void setUp() {
+ defaultLocation = new Location(43.6629, -79.3957);
+ defaultDateTime = LocalDateTime.of(2025, 11, 20, 19, 0);
+ }
+
+ @Nested
+ @DisplayName("Main Constructor Tests")
+ class MainConstructorTests {
+
+ @Test
+ @DisplayName("Should create event with all valid parameters")
+ void testConstructorWithValidParameters() {
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Test Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+
+ assertEquals("1", event.getId());
+ assertEquals("Test Event", event.getName());
+ assertEquals("Test Description", event.getDescription());
+ assertEquals("123 Main St", event.getAddress());
+ assertEquals(EventCategory.MUSIC, event.getCategory());
+ assertEquals(defaultLocation, event.getLocation());
+ assertEquals(defaultDateTime, event.getStartTime());
+ assertEquals("https://example.com/image.jpg", event.getImageUrl());
+ }
+
+ @Test
+ @DisplayName("Should set empty description for null description")
+ void testConstructorWithNullDescription() {
+ Event event = new Event(
+ "1",
+ "Test Event",
+ null,
+ "123 Main St",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+
+ assertEquals("", event.getDescription());
+ }
+
+ @Test
+ @DisplayName("Should set MISCELLANEOUS category for null category")
+ void testConstructorWithNullCategory() {
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ null,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+
+ assertEquals(EventCategory.MISCELLANEOUS, event.getCategory());
+ }
+
+ @Test
+ @DisplayName("Should set empty image URL for null image URL")
+ void testConstructorWithNullImageUrl() {
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ null
+ );
+
+ // Should return placeholder
+ assertTrue(event.getImageUrl().contains("placeholder"));
+ }
+
+ @Test
+ @DisplayName("Should set empty image URL for empty string image URL")
+ void testConstructorWithEmptyImageUrl() {
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ ""
+ );
+
+ // Should return placeholder
+ assertTrue(event.getImageUrl().contains("placeholder"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for null ID")
+ void testConstructorWithNullId() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Event(
+ null,
+ "Test Event",
+ "Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+ });
+
+ assertTrue(exception.getMessage().contains("Event ID"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for empty ID")
+ void testConstructorWithEmptyId() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Event(
+ "",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+ });
+
+ assertTrue(exception.getMessage().contains("Event ID"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for whitespace-only ID")
+ void testConstructorWithWhitespaceId() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Event(
+ " ",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+ });
+
+ assertTrue(exception.getMessage().contains("Event ID"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for null name")
+ void testConstructorWithNullName() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Event(
+ "1",
+ null,
+ "Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+ });
+
+ assertTrue(exception.getMessage().contains("Event name"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for empty name")
+ void testConstructorWithEmptyName() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Event(
+ "1",
+ "",
+ "Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+ });
+
+ assertTrue(exception.getMessage().contains("Event name"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for null address")
+ void testConstructorWithNullAddress() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Event(
+ "1",
+ "Test Event",
+ "Description",
+ null,
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+ });
+
+ assertTrue(exception.getMessage().contains("Event address"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for empty address")
+ void testConstructorWithEmptyAddress() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+ });
+
+ assertTrue(exception.getMessage().contains("Event address"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for null location")
+ void testConstructorWithNullLocation() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ null,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+ });
+
+ assertTrue(exception.getMessage().contains("Location"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for null start time")
+ void testConstructorWithNullStartTime() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ defaultLocation,
+ null,
+ "https://example.com/image.jpg"
+ );
+ });
+
+ assertTrue(exception.getMessage().contains("Start time"));
+ }
+ }
+
+ @Nested
+ @DisplayName("Convenience Constructor Tests")
+ class ConvenienceConstructorTests {
+
+ @Test
+ @DisplayName("Should create event with string category and datetime")
+ void testConvenienceConstructor() {
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ defaultLocation,
+ "Music",
+ "2025-11-20T19:00"
+ );
+
+ assertEquals("1", event.getId());
+ assertEquals("Test Event", event.getName());
+ assertEquals(EventCategory.MUSIC, event.getCategory());
+ assertEquals(2025, event.getStartTime().getYear());
+ assertEquals(11, event.getStartTime().getMonthValue());
+ assertEquals(20, event.getStartTime().getDayOfMonth());
+ assertEquals(19, event.getStartTime().getHour());
+ assertEquals(0, event.getStartTime().getMinute());
+ }
+
+ @Test
+ @DisplayName("Should parse category case-insensitively")
+ void testConvenienceConstructorCaseInsensitiveCategory() {
+ Event event1 = new Event("1", "Test", "Desc", "Addr", defaultLocation, "music", "2025-11-20T19:00");
+ Event event2 = new Event("2", "Test", "Desc", "Addr", defaultLocation, "MUSIC", "2025-11-20T19:00");
+ Event event3 = new Event("3", "Test", "Desc", "Addr", defaultLocation, "MuSiC", "2025-11-20T19:00");
+
+ assertEquals(EventCategory.MUSIC, event1.getCategory());
+ assertEquals(EventCategory.MUSIC, event2.getCategory());
+ assertEquals(EventCategory.MUSIC, event3.getCategory());
+ }
+
+ @Test
+ @DisplayName("Should default to MISCELLANEOUS for invalid category")
+ void testConvenienceConstructorInvalidCategory() {
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ defaultLocation,
+ "InvalidCategory",
+ "2025-11-20T19:00"
+ );
+
+ assertEquals(EventCategory.MISCELLANEOUS, event.getCategory());
+ }
+
+ @Test
+ @DisplayName("Should default to MISCELLANEOUS for null category")
+ void testConvenienceConstructorNullCategory() {
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ defaultLocation,
+ null,
+ "2025-11-20T19:00"
+ );
+
+ assertEquals(EventCategory.MISCELLANEOUS, event.getCategory());
+ }
+
+ @Test
+ @DisplayName("Should default to MISCELLANEOUS for empty category")
+ void testConvenienceConstructorEmptyCategory() {
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ defaultLocation,
+ "",
+ "2025-11-20T19:00"
+ );
+
+ assertEquals(EventCategory.MISCELLANEOUS, event.getCategory());
+ }
+
+ @Test
+ @DisplayName("Should default to current time for null datetime")
+ void testConvenienceConstructorNullDateTime() {
+ LocalDateTime before = LocalDateTime.now();
+
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ defaultLocation,
+ "Music",
+ null
+ );
+
+ LocalDateTime after = LocalDateTime.now();
+
+ assertFalse(event.getStartTime().isBefore(before));
+ assertFalse(event.getStartTime().isAfter(after));
+ }
+
+ @Test
+ @DisplayName("Should default to current time for empty datetime")
+ void testConvenienceConstructorEmptyDateTime() {
+ LocalDateTime before = LocalDateTime.now();
+
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ defaultLocation,
+ "Music",
+ ""
+ );
+
+ LocalDateTime after = LocalDateTime.now();
+
+ assertFalse(event.getStartTime().isBefore(before));
+ assertFalse(event.getStartTime().isAfter(after));
+ }
+
+ @Test
+ @DisplayName("Should default to current time for invalid datetime format")
+ void testConvenienceConstructorInvalidDateTime() {
+ LocalDateTime before = LocalDateTime.now();
+
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ defaultLocation,
+ "Music",
+ "invalid-date-format"
+ );
+
+ LocalDateTime after = LocalDateTime.now();
+
+ assertFalse(event.getStartTime().isBefore(before));
+ assertFalse(event.getStartTime().isAfter(after));
+ }
+
+ @Test
+ @DisplayName("Should have empty image URL with convenience constructor")
+ void testConvenienceConstructorImageUrl() {
+ Event event = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ defaultLocation,
+ "Music",
+ "2025-11-20T19:00"
+ );
+
+ // Should return placeholder since no image URL was provided
+ assertTrue(event.getImageUrl().contains("placeholder"));
+ }
+ }
+
+ @Nested
+ @DisplayName("Getter Tests")
+ class GetterTests {
+
+ private Event testEvent;
+
+ @BeforeEach
+ void setUp() {
+ testEvent = new Event(
+ "test-id",
+ "Test Event Name",
+ "Test Description",
+ "456 Test Street",
+ EventCategory.SPORTS,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/test.jpg"
+ );
+ }
+
+ @Test
+ @DisplayName("Should return correct ID")
+ void testGetId() {
+ assertEquals("test-id", testEvent.getId());
+ }
+
+ @Test
+ @DisplayName("Should return correct name")
+ void testGetName() {
+ assertEquals("Test Event Name", testEvent.getName());
+ }
+
+ @Test
+ @DisplayName("Should return correct description")
+ void testGetDescription() {
+ assertEquals("Test Description", testEvent.getDescription());
+ }
+
+ @Test
+ @DisplayName("Should return correct address")
+ void testGetAddress() {
+ assertEquals("456 Test Street", testEvent.getAddress());
+ }
+
+ @Test
+ @DisplayName("Should return correct category")
+ void testGetCategory() {
+ assertEquals(EventCategory.SPORTS, testEvent.getCategory());
+ }
+
+ @Test
+ @DisplayName("Should return correct location")
+ void testGetLocation() {
+ assertEquals(defaultLocation, testEvent.getLocation());
+ }
+
+ @Test
+ @DisplayName("Should return correct start time")
+ void testGetStartTime() {
+ assertEquals(defaultDateTime, testEvent.getStartTime());
+ }
+
+ @Test
+ @DisplayName("Should return correct image URL when provided")
+ void testGetImageUrlWhenProvided() {
+ assertEquals("https://example.com/test.jpg", testEvent.getImageUrl());
+ }
+
+ @Test
+ @DisplayName("Should return placeholder when image URL is empty")
+ void testGetImageUrlPlaceholder() {
+ Event eventWithoutImage = new Event(
+ "1",
+ "Test",
+ "Desc",
+ "Addr",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ ""
+ );
+
+ String imageUrl = eventWithoutImage.getImageUrl();
+
+ assertTrue(imageUrl.contains("placeholder"));
+ assertTrue(imageUrl.contains("No+Event+Image"));
+ }
+ }
+
+ @Nested
+ @DisplayName("Business Method Tests")
+ class BusinessMethodTests {
+
+ private Event testEvent;
+ private Location eventLocation;
+
+ @BeforeEach
+ void setUp() {
+ eventLocation = new Location(43.6532, -79.3832); // Toronto
+ testEvent = new Event(
+ "1",
+ "Test Event",
+ "Description",
+ "123 Main St",
+ EventCategory.MUSIC,
+ eventLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+ }
+
+ @Test
+ @DisplayName("Should return true when location is within radius")
+ void testIsWithinRadiusTrue() {
+ Location userLocation = new Location(43.6629, -79.3957); // ~1.5 km away
+
+ assertTrue(testEvent.isWithinRadius(userLocation, 2.0));
+ }
+
+ @Test
+ @DisplayName("Should return false when location is outside radius")
+ void testIsWithinRadiusFalse() {
+ Location userLocation = new Location(43.6629, -79.3957); // ~1.5 km away
+
+ assertFalse(testEvent.isWithinRadius(userLocation, 1.0));
+ }
+
+ @Test
+ @DisplayName("Should return false for null user location")
+ void testIsWithinRadiusNullLocation() {
+ assertFalse(testEvent.isWithinRadius(null, 5.0));
+ }
+
+ @Test
+ @DisplayName("Should return false for negative radius")
+ void testIsWithinRadiusNegativeRadius() {
+ Location userLocation = new Location(43.6629, -79.3957);
+
+ assertFalse(testEvent.isWithinRadius(userLocation, -1.0));
+ }
+
+ @Test
+ @DisplayName("Should return true when exactly at radius boundary")
+ void testIsWithinRadiusExactBoundary() {
+ Location userLocation = new Location(43.6629, -79.3957);
+ double exactDistance = testEvent.calculateDistanceTo(userLocation);
+
+ assertTrue(testEvent.isWithinRadius(userLocation, exactDistance));
+ }
+
+ @Test
+ @DisplayName("Should calculate correct distance to user location")
+ void testCalculateDistanceTo() {
+ Location userLocation = new Location(43.6629, -79.3957);
+
+ double distance = testEvent.calculateDistanceTo(userLocation);
+
+ assertTrue(distance > 0);
+ assertTrue(distance < 3.0); // Should be less than 3 km
+ }
+
+ @Test
+ @DisplayName("Should return MAX_VALUE for null user location in distance calculation")
+ void testCalculateDistanceToNull() {
+ double distance = testEvent.calculateDistanceTo(null);
+
+ assertEquals(Double.MAX_VALUE, distance);
+ }
+
+ @Test
+ @DisplayName("Should return true for matching category")
+ void testIsInCategoryTrue() {
+ assertTrue(testEvent.isInCategory(EventCategory.MUSIC));
+ }
+
+ @Test
+ @DisplayName("Should return false for non-matching category")
+ void testIsInCategoryFalse() {
+ assertFalse(testEvent.isInCategory(EventCategory.SPORTS));
+ }
+
+ @Test
+ @DisplayName("Should handle null category comparison")
+ void testIsInCategoryNull() {
+ assertFalse(testEvent.isInCategory(null));
+ }
+ }
+
+ @Nested
+ @DisplayName("Equals and HashCode Tests")
+ class EqualsAndHashCodeTests {
+
+ private Event event1;
+ private Event event2;
+
+ @BeforeEach
+ void setUp() {
+ event1 = new Event(
+ "same-id",
+ "Event Name",
+ "Description",
+ "Address",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+
+ event2 = new Event(
+ "same-id",
+ "Different Name",
+ "Different Description",
+ "Different Address",
+ EventCategory.SPORTS,
+ new Location(0, 0),
+ LocalDateTime.now(),
+ "https://different.com/image.jpg"
+ );
+ }
+
+ @Test
+ @DisplayName("Should be equal to itself")
+ void testEqualsItself() {
+ assertEquals(event1, event1);
+ }
+
+ @Test
+ @DisplayName("Should be equal to event with same ID")
+ void testEqualsSameId() {
+ assertEquals(event1, event2);
+ }
+
+ @Test
+ @DisplayName("Should not be equal to event with different ID")
+ void testNotEqualsDifferentId() {
+ Event differentEvent = new Event(
+ "different-id",
+ "Event Name",
+ "Description",
+ "Address",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+
+ assertNotEquals(event1, differentEvent);
+ }
+
+ @Test
+ @DisplayName("Should not be equal to null")
+ void testNotEqualsNull() {
+ assertNotEquals(null, event1);
+ }
+
+ @Test
+ @DisplayName("Should not be equal to different class object")
+ void testNotEqualsDifferentClass() {
+ assertNotEquals(event1, "Not an Event");
+ }
+
+ @Test
+ @DisplayName("Should have same hashCode for events with same ID")
+ void testHashCodeSameForSameId() {
+ assertEquals(event1.hashCode(), event2.hashCode());
+ }
+
+ @Test
+ @DisplayName("Should have different hashCode for events with different ID")
+ void testHashCodeDifferentForDifferentId() {
+ Event differentEvent = new Event(
+ "different-id",
+ "Event Name",
+ "Description",
+ "Address",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+
+ assertNotEquals(event1.hashCode(), differentEvent.hashCode());
+ }
+
+ @Test
+ @DisplayName("Should have consistent hashCode")
+ void testHashCodeConsistent() {
+ int hash1 = event1.hashCode();
+ int hash2 = event1.hashCode();
+
+ assertEquals(hash1, hash2);
+ }
+ }
+
+ @Nested
+ @DisplayName("ToString Tests")
+ class ToStringTests {
+
+ private Event testEvent;
+
+ @BeforeEach
+ void setUp() {
+ testEvent = new Event(
+ "test-id",
+ "Test Event",
+ "Description",
+ "Address",
+ EventCategory.MUSIC,
+ defaultLocation,
+ defaultDateTime,
+ "https://example.com/image.jpg"
+ );
+ }
+
+ @Test
+ @DisplayName("Should contain ID in toString")
+ void testToStringContainsId() {
+ String result = testEvent.toString();
+
+ assertTrue(result.contains("test-id"));
+ }
+
+ @Test
+ @DisplayName("Should contain name in toString")
+ void testToStringContainsName() {
+ String result = testEvent.toString();
+
+ assertTrue(result.contains("Test Event"));
+ }
+
+ @Test
+ @DisplayName("Should contain category in toString")
+ void testToStringContainsCategory() {
+ String result = testEvent.toString();
+
+ assertTrue(result.contains("MUSIC") || result.contains("Music"));
+ }
+
+ @Test
+ @DisplayName("Should contain image URL in toString")
+ void testToStringContainsImageUrl() {
+ String result = testEvent.toString();
+
+ assertTrue(result.contains("example.com"));
+ }
+
+ @Test
+ @DisplayName("Should have proper format")
+ void testToStringFormat() {
+ String result = testEvent.toString();
+
+ assertTrue(result.startsWith("Event{"));
+ assertTrue(result.contains("id="));
+ assertTrue(result.contains("name="));
+ assertTrue(result.contains("category="));
+ assertTrue(result.contains("image="));
+ assertTrue(result.endsWith("}"));
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/entity/LocationTest.java b/src/test/java/entity/LocationTest.java
new file mode 100644
index 00000000..2cebb96d
--- /dev/null
+++ b/src/test/java/entity/LocationTest.java
@@ -0,0 +1,372 @@
+package entity;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class LocationTest {
+
+ @Nested
+ @DisplayName("Constructor Tests")
+ class ConstructorTests {
+
+ @Test
+ @DisplayName("Should create location with latitude and longitude only")
+ void testConstructorWithCoordinatesOnly() {
+ Location location = new Location(43.6629, -79.3957);
+
+ assertEquals(43.6629, location.getLatitude(), 0.0001);
+ assertEquals(-79.3957, location.getLongitude(), 0.0001);
+ assertEquals("", location.getAddress());
+ }
+
+ @Test
+ @DisplayName("Should create location with address and coordinates")
+ void testConstructorWithAddressAndCoordinates() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+
+ assertEquals("123 Main St", location.getAddress());
+ assertEquals(43.6629, location.getLatitude(), 0.0001);
+ assertEquals(-79.3957, location.getLongitude(), 0.0001);
+ }
+
+ @Test
+ @DisplayName("Should trim whitespace from address")
+ void testConstructorTrimsAddress() {
+ Location location = new Location(" 123 Main St ", 43.6629, -79.3957);
+
+ assertEquals("123 Main St", location.getAddress());
+ }
+
+ @Test
+ @DisplayName("Should handle null address by setting empty string")
+ void testConstructorWithNullAddress() {
+ Location location = new Location(null, 43.6629, -79.3957);
+
+ assertEquals("", location.getAddress());
+ assertNotNull(location.getAddress());
+ }
+
+ @Test
+ @DisplayName("Should throw exception for latitude above 90")
+ void testConstructorWithLatitudeAbove90() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Location(91.0, -79.3957);
+ });
+
+ assertTrue(exception.getMessage().contains("Latitude"));
+ assertTrue(exception.getMessage().contains("90"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for latitude below -90")
+ void testConstructorWithLatitudeBelow90() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Location(-91.0, -79.3957);
+ });
+
+ assertTrue(exception.getMessage().contains("Latitude"));
+ assertTrue(exception.getMessage().contains("-90"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for longitude above 180")
+ void testConstructorWithLongitudeAbove180() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Location(43.6629, 181.0);
+ });
+
+ assertTrue(exception.getMessage().contains("Longitude"));
+ assertTrue(exception.getMessage().contains("180"));
+ }
+
+ @Test
+ @DisplayName("Should throw exception for longitude below -180")
+ void testConstructorWithLongitudeBelow180() {
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ new Location(43.6629, -181.0);
+ });
+
+ assertTrue(exception.getMessage().contains("Longitude"));
+ assertTrue(exception.getMessage().contains("-180"));
+ }
+
+ @Test
+ @DisplayName("Should accept boundary latitude values")
+ void testConstructorWithBoundaryLatitudes() {
+ Location location1 = new Location(90.0, 0.0);
+ Location location2 = new Location(-90.0, 0.0);
+
+ assertEquals(90.0, location1.getLatitude(), 0.0001);
+ assertEquals(-90.0, location2.getLatitude(), 0.0001);
+ }
+
+ @Test
+ @DisplayName("Should accept boundary longitude values")
+ void testConstructorWithBoundaryLongitudes() {
+ Location location1 = new Location(0.0, 180.0);
+ Location location2 = new Location(0.0, -180.0);
+
+ assertEquals(180.0, location1.getLongitude(), 0.0001);
+ assertEquals(-180.0, location2.getLongitude(), 0.0001);
+ }
+ }
+
+ @Nested
+ @DisplayName("Distance Calculation Tests")
+ class DistanceCalculationTests {
+
+ @Test
+ @DisplayName("Should calculate distance between two locations")
+ void testCalculateDistanceBetweenTwoLocations() {
+ // Toronto to Mississauga (approximate)
+ Location toronto = new Location(43.6532, -79.3832);
+ Location mississauga = new Location(43.5890, -79.6441);
+
+ double distance = toronto.calculateDistance(mississauga);
+
+ // Distance should be approximately 23-24 km
+ assertTrue(distance > 22.0 && distance < 25.0,
+ "Distance should be approximately 23-24 km, was: " + distance);
+ }
+
+ @Test
+ @DisplayName("Should calculate zero distance for same location")
+ void testCalculateDistanceSameLocation() {
+ Location location = new Location(43.6532, -79.3832);
+
+ double distance = location.calculateDistance(location);
+
+ assertEquals(0.0, distance, 0.001);
+ }
+
+ @Test
+ @DisplayName("Should calculate distance with very close coordinates")
+ void testCalculateDistanceVeryClose() {
+ Location loc1 = new Location(43.6532, -79.3832);
+ Location loc2 = new Location(43.6533, -79.3833);
+
+ double distance = loc1.calculateDistance(loc2);
+
+ // Should be very small (less than 0.2 km)
+ assertTrue(distance < 0.2,
+ "Distance should be very small, was: " + distance);
+ }
+
+ @Test
+ @DisplayName("Should return MAX_VALUE when calculating distance to null location")
+ void testCalculateDistanceToNull() {
+ Location location = new Location(43.6532, -79.3832);
+
+ double distance = location.calculateDistance(null);
+
+ assertEquals(Double.MAX_VALUE, distance);
+ }
+
+ @Test
+ @DisplayName("Should calculate long distance correctly (Toronto to Vancouver)")
+ void testCalculateLongDistance() {
+ Location toronto = new Location(43.6532, -79.3832);
+ Location vancouver = new Location(49.2827, -123.1207);
+
+ double distance = toronto.calculateDistance(vancouver);
+
+ // Distance should be approximately 3350-3400 km
+ assertTrue(distance > 3300 && distance < 3450,
+ "Distance Toronto-Vancouver should be ~3350-3400 km, was: " + distance);
+ }
+
+ @Test
+ @DisplayName("Should calculate distance across the equator")
+ void testCalculateDistanceAcrossEquator() {
+ Location northernHemisphere = new Location(10.0, 0.0);
+ Location southernHemisphere = new Location(-10.0, 0.0);
+
+ double distance = northernHemisphere.calculateDistance(southernHemisphere);
+
+ // Distance should be approximately 2220 km (20 degrees of latitude)
+ assertTrue(distance > 2200 && distance < 2250,
+ "Distance should be approximately 2220 km, was: " + distance);
+ }
+
+ @Test
+ @DisplayName("Should calculate distance at the poles")
+ void testCalculateDistanceAtPoles() {
+ Location northPole = new Location(90.0, 0.0);
+ Location southPole = new Location(-90.0, 0.0);
+
+ double distance = northPole.calculateDistance(southPole);
+
+ // Distance should be approximately half Earth's circumference (~20,000 km)
+ assertTrue(distance > 19900 && distance < 20100,
+ "Distance pole to pole should be ~20,000 km, was: " + distance);
+ }
+ }
+
+ @Nested
+ @DisplayName("Equals and HashCode Tests")
+ class EqualsAndHashCodeTests {
+
+ @Test
+ @DisplayName("Should be equal to itself")
+ void testEqualsItself() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+
+ assertEquals(location, location);
+ }
+
+ @Test
+ @DisplayName("Should be equal to location with same values")
+ void testEqualsSameValues() {
+ Location location1 = new Location("123 Main St", 43.6629, -79.3957);
+ Location location2 = new Location("123 Main St", 43.6629, -79.3957);
+
+ assertEquals(location1, location2);
+ assertEquals(location2, location1);
+ }
+
+ @Test
+ @DisplayName("Should not be equal to location with different address")
+ void testNotEqualsDifferentAddress() {
+ Location location1 = new Location("123 Main St", 43.6629, -79.3957);
+ Location location2 = new Location("456 Oak Ave", 43.6629, -79.3957);
+
+ assertNotEquals(location1, location2);
+ }
+
+ @Test
+ @DisplayName("Should not be equal to location with different latitude")
+ void testNotEqualsDifferentLatitude() {
+ Location location1 = new Location("123 Main St", 43.6629, -79.3957);
+ Location location2 = new Location("123 Main St", 43.7629, -79.3957);
+
+ assertNotEquals(location1, location2);
+ }
+
+ @Test
+ @DisplayName("Should not be equal to location with different longitude")
+ void testNotEqualsDifferentLongitude() {
+ Location location1 = new Location("123 Main St", 43.6629, -79.3957);
+ Location location2 = new Location("123 Main St", 43.6629, -79.4957);
+
+ assertNotEquals(location1, location2);
+ }
+
+ @Test
+ @DisplayName("Should not be equal to null")
+ void testNotEqualsNull() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+
+ assertNotEquals(null, location);
+ }
+
+ @Test
+ @DisplayName("Should not be equal to different class object")
+ void testNotEqualsDifferentClass() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+ String notALocation = "Not a location";
+
+ assertNotEquals(location, notALocation);
+ }
+
+ @Test
+ @DisplayName("Should have same hashCode for equal locations")
+ void testHashCodeSameForEqualLocations() {
+ Location location1 = new Location("123 Main St", 43.6629, -79.3957);
+ Location location2 = new Location("123 Main St", 43.6629, -79.3957);
+
+ assertEquals(location1.hashCode(), location2.hashCode());
+ }
+
+ @Test
+ @DisplayName("Should have consistent hashCode")
+ void testHashCodeConsistent() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+
+ int hashCode1 = location.hashCode();
+ int hashCode2 = location.hashCode();
+
+ assertEquals(hashCode1, hashCode2);
+ }
+ }
+
+ @Nested
+ @DisplayName("ToString Tests")
+ class ToStringTests {
+
+ @Test
+ @DisplayName("Should contain address in toString")
+ void testToStringContainsAddress() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+
+ String result = location.toString();
+
+ assertTrue(result.contains("123 Main St"));
+ }
+
+ @Test
+ @DisplayName("Should contain latitude in toString")
+ void testToStringContainsLatitude() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+
+ String result = location.toString();
+
+ assertTrue(result.contains("43.6"));
+ }
+
+ @Test
+ @DisplayName("Should contain longitude in toString")
+ void testToStringContainsLongitude() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+
+ String result = location.toString();
+
+ assertTrue(result.contains("-79.3"));
+ }
+
+ @Test
+ @DisplayName("Should have proper format")
+ void testToStringFormat() {
+ Location location = new Location("Test Address", 43.6629, -79.3957);
+
+ String result = location.toString();
+
+ assertTrue(result.startsWith("Location{"));
+ assertTrue(result.contains("address="));
+ assertTrue(result.contains("latitude="));
+ assertTrue(result.contains("longitude="));
+ assertTrue(result.endsWith("}"));
+ }
+ }
+
+ @Nested
+ @DisplayName("Getter Tests")
+ class GetterTests {
+
+ @Test
+ @DisplayName("Should return correct address")
+ void testGetAddress() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+
+ assertEquals("123 Main St", location.getAddress());
+ }
+
+ @Test
+ @DisplayName("Should return correct latitude")
+ void testGetLatitude() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+
+ assertEquals(43.6629, location.getLatitude(), 0.0001);
+ }
+
+ @Test
+ @DisplayName("Should return correct longitude")
+ void testGetLongitude() {
+ Location location = new Location("123 Main St", 43.6629, -79.3957);
+
+ assertEquals(-79.3957, location.getLongitude(), 0.0001);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/use_case/calendarFlow/CalendarFlowInteractorTest.java b/src/test/java/use_case/calendarFlow/CalendarFlowInteractorTest.java
new file mode 100644
index 00000000..d6deeff1
--- /dev/null
+++ b/src/test/java/use_case/calendarFlow/CalendarFlowInteractorTest.java
@@ -0,0 +1,320 @@
+package use_case.calendarFlow;
+
+import entity.Event;
+import entity.EventCategory;
+import entity.Location;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Test class for CalendarFlowInteractor.
+ * Tests the business logic for fetching events by date.
+ */
+public class CalendarFlowInteractorTest {
+
+ private CalendarFlowInteractor interactor;
+ private MockCalendarFlowDataAccess mockDataAccess;
+ private MockCalendarFlowPresenter mockPresenter;
+
+ @BeforeEach
+ public void setUp() {
+ mockDataAccess = new MockCalendarFlowDataAccess();
+ mockPresenter = new MockCalendarFlowPresenter();
+ interactor = new CalendarFlowInteractor(mockDataAccess, mockPresenter);
+ }
+
+
+ @Test
+ public void testSuccessfulEventRetrieval() {
+ // Setup test data
+ LocalDate date = LocalDate.of(2024, 11, 22);
+ Location location = new Location("Toronto, ON", 43.6532, -79.3832);
+ double radius = 50.0;
+
+ // Create input data
+ CalendarFlowInputData inputData = new CalendarFlowInputData(date, location, radius);
+
+ // Execute
+ interactor.execute(inputData);
+
+ // Verify success view was called
+ assertTrue(mockPresenter.isSuccessViewCalled());
+ assertFalse(mockPresenter.isFailViewCalled());
+
+ // Verify output data
+ assertNotNull(mockPresenter.getOutputData());
+ assertEquals(date, mockPresenter.getOutputData().getSelectedDate());
+ assertEquals(3, mockPresenter.getOutputData().getEvents().size());
+ }
+
+ @Test
+ public void testNoEventsFound() {
+ // Setup - data access returns empty list
+ mockDataAccess.setReturnEmptyList(true);
+
+ LocalDate date = LocalDate.of(2024, 12, 25);
+ Location location = new Location("Toronto, ON", 43.6532, -79.3832);
+ double radius = 50.0;
+
+ CalendarFlowInputData inputData = new CalendarFlowInputData(date, location, radius);
+
+ // Execute
+ interactor.execute(inputData);
+
+ // Verify fail view was called
+ assertFalse(mockPresenter.isSuccessViewCalled());
+ assertTrue(mockPresenter.isFailViewCalled());
+ assertTrue(mockPresenter.getErrorMessage().contains("No events found"));
+ }
+
+ @Test
+ public void testNullDate() {
+ // Create input with null date
+ Location location = new Location("Toronto, ON", 43.6532, -79.3832);
+ CalendarFlowInputData inputData = new CalendarFlowInputData(null, location, 50.0);
+
+ // Execute
+ interactor.execute(inputData);
+
+ // Verify fail view was called with appropriate error
+ assertTrue(mockPresenter.isFailViewCalled());
+ assertFalse(mockPresenter.isSuccessViewCalled());
+ assertEquals("Date cannot be null", mockPresenter.getErrorMessage());
+ }
+
+ @Test
+ public void testNullEventList() {
+ mockDataAccess.setReturnNull(true);
+
+ LocalDate date = LocalDate.of(2024, 11, 22);
+ Location location = new Location("Toronto, ON", 43.6532, -79.3832);
+ CalendarFlowInputData inputData = new CalendarFlowInputData(date, location, 50.0);
+
+ interactor.execute(inputData);
+
+ assertTrue(mockPresenter.isFailViewCalled());
+ assertTrue(mockPresenter.getErrorMessage().contains("No events found"));
+ }
+
+ @Test
+ public void testNullLocation() {
+ // Create input with null location
+ LocalDate date = LocalDate.of(2024, 11, 22);
+ CalendarFlowInputData inputData = new CalendarFlowInputData(date, null, 50.0);
+
+ // Execute
+ interactor.execute(inputData);
+
+ // Verify fail view was called with appropriate error
+ assertTrue(mockPresenter.isFailViewCalled());
+ assertFalse(mockPresenter.isSuccessViewCalled());
+ assertEquals("User location is required", mockPresenter.getErrorMessage());
+ }
+
+ @Test
+ public void testDataAccessException() {
+ // Setup - data access throws exception
+ mockDataAccess.setShouldThrowException(true);
+
+ LocalDate date = LocalDate.of(2024, 11, 22);
+ Location location = new Location("Toronto, ON", 43.6532, -79.3832);
+ CalendarFlowInputData inputData = new CalendarFlowInputData(date, location, 50.0);
+
+ // Execute
+ interactor.execute(inputData);
+
+ // Verify fail view was called
+ assertTrue(mockPresenter.isFailViewCalled());
+ assertFalse(mockPresenter.isSuccessViewCalled());
+ assertTrue(mockPresenter.getErrorMessage().contains("Error fetching events"));
+ }
+
+ @Test
+ public void testDifferentRadii() {
+ // Test with small radius
+ LocalDate date = LocalDate.of(2024, 11, 22);
+ Location location = new Location("Toronto, ON", 43.6532, -79.3832);
+
+ CalendarFlowInputData inputData1 = new CalendarFlowInputData(date, location, 10.0);
+ interactor.execute(inputData1);
+ assertTrue(mockPresenter.isSuccessViewCalled());
+
+ // Reset
+ mockPresenter.reset();
+
+ // Test with large radius
+ CalendarFlowInputData inputData2 = new CalendarFlowInputData(date, location, 100.0);
+ interactor.execute(inputData2);
+ assertTrue(mockPresenter.isSuccessViewCalled());
+ }
+
+ @Test
+ public void testMultipleExecutions() {
+ LocalDate date1 = LocalDate.of(2024, 11, 22);
+ LocalDate date2 = LocalDate.of(2024, 11, 23);
+ Location location = new Location("Toronto, ON", 43.6532, -79.3832);
+
+ // First execution
+ CalendarFlowInputData inputData1 = new CalendarFlowInputData(date1, location, 50.0);
+ interactor.execute(inputData1);
+ assertTrue(mockPresenter.isSuccessViewCalled());
+
+ // Reset presenter
+ mockPresenter.reset();
+
+ // Second execution
+ CalendarFlowInputData inputData2 = new CalendarFlowInputData(date2, location, 50.0);
+ interactor.execute(inputData2);
+ assertTrue(mockPresenter.isSuccessViewCalled());
+ }
+
+ /**
+ * Mock implementation of CalendarFlowDataAccessInterface for testing.
+ */
+ private static class MockCalendarFlowDataAccess implements CalendarFlowDataAccessInterface {
+ private boolean returnEmptyList = false;
+ private boolean shouldThrowException = false;
+ private boolean returnNull = false;
+
+ public void setReturnEmptyList(boolean returnEmptyList) {
+ this.returnEmptyList = returnEmptyList;
+ }
+
+ public void setReturnNull(boolean returnNull) {
+ this.returnNull = returnNull;
+ }
+
+ public void setShouldThrowException(boolean shouldThrowException) {
+ this.shouldThrowException = shouldThrowException;
+ }
+
+ @Override
+ public List getEventsByDate(LocalDate date, Location location, double radiusKm) {
+ if (shouldThrowException) {
+ throw new RuntimeException("API connection failed");
+ }
+ if (returnNull) {
+ return null;
+ }
+ if (returnEmptyList) {
+ return new ArrayList<>();
+ }
+
+ // Return mock events
+ List events = new ArrayList<>();
+
+ Location loc1 = new Location("Scotiabank Arena, Toronto, ON", 43.6435, -79.3791);
+ Event event1 = new Event(
+ "1",
+ "Toronto Maple Leafs vs Boston Bruins",
+ "Hockey game",
+ "Address",
+ EventCategory.SPORTS,
+ loc1,
+ LocalDateTime.of(2024, 11, 22, 19, 0),
+ "https://example.com/image1.jpg"
+ );
+
+ Location loc2 = new Location("Rogers Centre, Toronto, ON", 43.6414, -79.3894);
+ Event event2 = new Event(
+ "2",
+ "Drake Concert",
+ "Music concert",
+ "Toronto",
+ EventCategory.MUSIC,
+ loc2,
+ LocalDateTime.of(2024, 11, 22, 20, 30),
+ "https://example.com/image2.jpg"
+ );
+
+ Location loc3 = new Location("Second City, Toronto, ON", 43.6426, -79.3871);
+ Event event3 = new Event(
+ "3",
+ "Comedy Night",
+ "Comedy show",
+ "Toronto2",
+ EventCategory.ARTS_THEATRE,
+ loc3,
+ LocalDateTime.of(2024, 11, 22, 21, 0),
+ "https://example.com/image3.jpg"
+ );
+
+ events.add(event1);
+ events.add(event2);
+ events.add(event3);
+
+ return events;
+ }
+ }
+
+ @Test
+ public void testSwitchToDashboardViewDelegatesToPresenter() {
+ assertFalse(mockPresenter.isSwitchToDashboardViewCalled());
+ interactor.switchToDashboardView();
+ assertTrue(mockPresenter.isSwitchToDashboardViewCalled());
+ }
+
+ /**
+ * Mock implementation of CalendarFlowOutputBoundary for testing.
+ */
+ private static class MockCalendarFlowPresenter implements CalendarFlowOutputBoundary {
+ private boolean successViewCalled = false;
+ private boolean failViewCalled = false;
+ private CalendarFlowOutputData outputData;
+ private String errorMessage;
+ private boolean switchToDashboardViewCalled = false; // NEW
+
+
+ @Override
+ public void prepareSuccessView(CalendarFlowOutputData outputData) {
+ this.successViewCalled = true;
+ this.outputData = outputData;
+ }
+
+ @Override
+ public void prepareFailView(String errorMessage) {
+ this.failViewCalled = true;
+ this.errorMessage = errorMessage;
+ }
+
+ public boolean isSuccessViewCalled() {
+ return successViewCalled;
+ }
+
+ public boolean isFailViewCalled() {
+ return failViewCalled;
+ }
+
+ @Override
+ public void switchToDashboardView() { // NEW
+ this.switchToDashboardViewCalled = true; // NEW
+ }
+
+ public boolean isSwitchToDashboardViewCalled() { // NEW
+ return switchToDashboardViewCalled;
+ }
+
+ public CalendarFlowOutputData getOutputData() {
+ return outputData;
+ }
+
+ public String getErrorMessage() {
+ return errorMessage;
+ }
+
+ public void reset() {
+ successViewCalled = false;
+ failViewCalled = false;
+ switchToDashboardViewCalled = false;
+ outputData = null;
+ errorMessage = null;
+ }
+ }
+}
diff --git a/src/test/java/use_case/calendarFlow/viewDemoAndTest/CalendarFlowDataAccessObjectTest.java b/src/test/java/use_case/calendarFlow/viewDemoAndTest/CalendarFlowDataAccessObjectTest.java
new file mode 100644
index 00000000..b69ecac0
--- /dev/null
+++ b/src/test/java/use_case/calendarFlow/viewDemoAndTest/CalendarFlowDataAccessObjectTest.java
@@ -0,0 +1,66 @@
+package use_case.calendarFlow.viewDemoAndTest;
+
+import data_access.CalendarFlowDataAccessObject;
+import entity.Event;
+import entity.Location;
+import interface_adapter.calendarFlow.CalendarFlowState;
+import interface_adapter.calendarFlow.CalendarFlowViewModel;
+import view.EventListByDateView;
+
+import javax.swing.*;
+ import java.time.LocalDate;
+import java.util.List;
+
+/**
+ * Simple manual test/demo:
+ * - makes up a date, location, radius
+ * - calls CalendarFlowDataAccessObject.getEventsByDate(...)
+ * - shows the result in EventListByDateView
+ */
+public class CalendarFlowDataAccessObjectTest {
+
+ public static void main(String[] args) {
+ // 1. Make up test inputs (change these to whatever you want)
+ LocalDate selectedDate = LocalDate.of(2025, 11, 30);
+ Location userLocation = new Location(
+ "Downtown Toronto",
+ 43.6532, // latitude
+ -79.3832 // longitude
+ );
+ double radiusKm = 10.0;
+
+ // 2. Call the real data access object
+ CalendarFlowDataAccessObject dao = new CalendarFlowDataAccessObject();
+ List events = dao.getEventsByDate(selectedDate, userLocation, radiusKm);
+
+ // Just to see something in console as well
+ System.out.println("Selected date: " + selectedDate);
+ System.out.println("Location: " + userLocation);
+ System.out.println("Radius (km): " + radiusKm);
+ System.out.println("Number of events returned: " + events.size());
+
+ // 3. Show the result in EventListByDateView
+ SwingUtilities.invokeLater(() -> {
+ // ViewModel and View
+ CalendarFlowViewModel viewModel = new CalendarFlowViewModel();
+ EventListByDateView view = new EventListByDateView(viewModel);
+
+ // Build state from the DAO result
+ CalendarFlowState state = new CalendarFlowState();
+ state.setDate(selectedDate);
+ state.setEventList(events);
+
+ // Push state into the ViewModel (this will trigger propertyChange on the view)
+ viewModel.setState(state);
+ viewModel.firePropertyChange();
+
+ // 4. Wrap the view in a frame and show it
+ JFrame frame = new JFrame("Events for " + selectedDate);
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ frame.setContentPane(view);
+ frame.pack();
+ frame.setLocationRelativeTo(null);
+ frame.setVisible(true);
+ });
+ }
+}
diff --git a/src/test/java/use_case/calendarFlow/viewDemoAndTest/CalendarFlowViewDemo.java b/src/test/java/use_case/calendarFlow/viewDemoAndTest/CalendarFlowViewDemo.java
new file mode 100644
index 00000000..2c01131e
--- /dev/null
+++ b/src/test/java/use_case/calendarFlow/viewDemoAndTest/CalendarFlowViewDemo.java
@@ -0,0 +1,18 @@
+package use_case.calendarFlow.viewDemoAndTest;
+
+import view.CalendarView;
+import javax.swing.*;
+
+public class CalendarFlowViewDemo {
+ public static void main(String[] args) {
+ SwingUtilities.invokeLater(() -> {
+ JFrame frame = new JFrame("Calendar Demo");
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ CalendarView calendarView = new CalendarView();
+ frame.add(calendarView);
+ frame.pack();
+ frame.setLocationRelativeTo(null); // Center on screen
+ frame.setVisible(true);
+ });
+ }
+}
diff --git a/src/test/java/use_case/calendarFlow/viewDemoAndTest/CodeCombinationTest.java b/src/test/java/use_case/calendarFlow/viewDemoAndTest/CodeCombinationTest.java
new file mode 100644
index 00000000..5a28ae6e
--- /dev/null
+++ b/src/test/java/use_case/calendarFlow/viewDemoAndTest/CodeCombinationTest.java
@@ -0,0 +1,157 @@
+//Assisted by AI
+package use_case.calendarFlow.viewDemoAndTest;
+// ============================================
+// SimpleCalendarAPITest.java
+// Simple test: Click date → See REAL events from API
+// With YOUR mock location and radius
+// ============================================
+
+import use_case.calendarFlow.CalendarFlowDataAccessInterface;
+import use_case.calendarFlow.CalendarFlowInputBoundary;
+import use_case.calendarFlow.CalendarFlowInteractor;
+import use_case.calendarFlow.CalendarFlowOutputBoundary;
+import view.CalendarView;
+import view.EventListByDateView;
+import interface_adapter.calendarFlow.*;
+import interface_adapter.ViewManagerModel;
+import data_access.CalendarFlowDataAccessObject;
+import entity.Location;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * SIMPLE TEST to see real API results
+ *
+ * What you'll see:
+ * 1. Calendar view opens
+ * 2. Click any date
+ * 3. Real API call with YOUR location and radius
+ * 4. Event list shows REAL events from Ticketmaster
+ *
+ * Mock Data:
+ * - Location: Toronto, ON (43.6532, -79.3832)
+ * - Radius: 100 km
+ *
+ * You can change these below!
+ */
+public class CodeCombinationTest {
+
+ // ============================================
+ // 🎯 CHANGE THESE TO TEST DIFFERENT LOCATIONS
+ // ============================================
+ private static final String TEST_LOCATION_NAME = "Toronto, ON";
+ private static final double TEST_LATITUDE = 43.6532;
+ private static final double TEST_LONGITUDE = -79.3832;
+ private static final double TEST_RADIUS_KM = 100.0;
+
+ // Other test locations you can try:
+ // Montreal: 45.5019, -73.5674
+ // New York: 40.7128, -74.0060
+ // Los Angeles: 34.0522, -118.2437
+ // Chicago: 41.8781, -87.6298
+
+ public static void main(String[] args) {
+ System.out.println("╔════════════════════════════════════════════════════════╗");
+ System.out.println("║ SIMPLE CALENDAR API TEST ║");
+ System.out.println("║ Real Ticketmaster Events ║");
+ System.out.println("╚════════════════════════════════════════════════════════╝\n");
+
+ System.out.println("📍 Test Configuration:");
+ System.out.println(" Location: " + TEST_LOCATION_NAME);
+ System.out.println(" Coordinates: (" + TEST_LATITUDE + ", " + TEST_LONGITUDE + ")");
+ System.out.println(" Search Radius: " + TEST_RADIUS_KM + " km");
+ System.out.println();
+ System.out.println("⚠️ Make sure API key is set in CalendarFlowDataAccessObject.java");
+ System.out.println(" Line: private static final String API_KEY = \"YOUR_KEY_HERE\";\n");
+
+ SwingUtilities.invokeLater(() -> {
+ // Create test location
+ Location testLocation = new Location(TEST_LOCATION_NAME, TEST_LATITUDE, TEST_LONGITUDE);
+
+ // Setup view switching
+ CardLayout cardLayout = new CardLayout();
+ JPanel cardPanel = new JPanel(cardLayout);
+
+ ViewManagerModel viewManagerModel = new ViewManagerModel();
+ viewManagerModel.addPropertyChangeListener(evt -> {
+ if (evt.getPropertyName().equals("state")) {
+ String viewName = (String) evt.getNewValue();
+ cardLayout.show(cardPanel, viewName);
+ System.out.println("→ Switched to: " + viewName);
+ }
+ });
+
+ // Create ViewModel
+ CalendarFlowViewModel viewModel = new CalendarFlowViewModel();
+
+ // Create Views
+ CalendarView calendarView = new CalendarView();
+ EventListByDateView eventListView = new EventListByDateView(viewModel);
+
+ // Create Use Case with REAL API
+ CalendarFlowDataAccessInterface dataAccess = new CalendarFlowDataAccessObject();
+ CalendarFlowOutputBoundary presenter = new CalendarFlowPresenter(viewModel, viewManagerModel);
+ CalendarFlowInputBoundary interactor = new CalendarFlowInteractor(dataAccess, presenter);
+ CalendarFlowController controller = new CalendarFlowController(interactor);
+
+ // Wire up views with TEST location and radius
+ calendarView.setUserLocation(testLocation);
+ calendarView.setSearchRadiusKm(TEST_RADIUS_KM);
+ calendarView.setEventController(controller);
+
+ eventListView.setController(controller);
+
+ // Add views to panel
+ cardPanel.add(calendarView, "calendar view");
+ cardPanel.add(eventListView, "event list by date");
+
+ // Create window
+ JFrame frame = new JFrame("Calendar API Test - " + TEST_LOCATION_NAME);
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ frame.add(cardPanel);
+ frame.setSize(900, 700);
+ frame.setLocationRelativeTo(null);
+
+ // Start with calendar view
+ cardLayout.show(cardPanel, "calendar view");
+ frame.setVisible(true);
+
+ // Instructions
+ System.out.println("✅ Application started!\n");
+ System.out.println("╔════════════════════════════════════════════════════════╗");
+ System.out.println("║ HOW TO USE ║");
+ System.out.println("╚════════════════════════════════════════════════════════╝");
+ System.out.println("1. You see the calendar");
+ System.out.println("2. Click ANY date");
+ System.out.println("3. Watch console for API call details");
+ System.out.println("4. Wait 1-2 seconds for API response");
+ System.out.println("5. See REAL events in the list!");
+ System.out.println();
+ System.out.println("╔════════════════════════════════════════════════════════╗");
+ System.out.println("║ WHAT YOU'LL SEE IN THE EVENT LIST ║");
+ System.out.println("╚════════════════════════════════════════════════════════╝");
+ System.out.println("• Event name (e.g., 'Toronto Raptors vs Lakers')");
+ System.out.println("• Venue address (e.g., 'Scotiabank Arena, 40 Bay St')");
+ System.out.println("• Event time (e.g., '7:30 PM')");
+ System.out.println("• Category indicator (Sports/Music/Arts/Film)");
+ System.out.println();
+ System.out.println("╔════════════════════════════════════════════════════════╗");
+ System.out.println("║ WATCH CONSOLE FOR ║");
+ System.out.println("╚════════════════════════════════════════════════════════╝");
+ System.out.println("• Selected date");
+ System.out.println("• API request details");
+ System.out.println("• Number of events found");
+ System.out.println("• Event details");
+ System.out.println();
+ });
+ }
+}
+
+// ============================================
+// DetailedCalendarAPITest.java
+// Same as above but with DETAILED console output
+// Shows exactly what API returns
+// ============================================
+
+
diff --git a/src/test/java/use_case/calendarFlow/viewDemoAndTest/EventListByDateViewTest.java b/src/test/java/use_case/calendarFlow/viewDemoAndTest/EventListByDateViewTest.java
new file mode 100644
index 00000000..ce2bf476
--- /dev/null
+++ b/src/test/java/use_case/calendarFlow/viewDemoAndTest/EventListByDateViewTest.java
@@ -0,0 +1,184 @@
+package use_case.calendarFlow.viewDemoAndTest;
+
+import entity.Event;
+import entity.EventCategory;
+import entity.Location;
+import interface_adapter.calendarFlow.CalendarFlowState;
+import interface_adapter.calendarFlow.CalendarFlowViewModel;
+import view.EventListByDateView;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import javax.swing.*;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Test class for EventListByDateView.
+ * Tests the UI rendering and state changes.
+ */
+public class EventListByDateViewTest {
+ private EventListByDateView view;
+ private CalendarFlowViewModel viewModel;
+
+ /**
+ * Helper method to create test events
+ */
+ private static List createTestEvents() {
+ List events = new ArrayList<>();
+
+ Location location1 = new Location("Scotiabank Arena, Toronto, ON", 43.6435, -79.3791);
+ Event event1 = new Event(
+ "1",
+ "Toronto Maple Leafs vs Boston Bruins",
+ "Exciting hockey game",
+ "Demo Address 1",
+ EventCategory.SPORTS,
+ location1,
+ LocalDateTime.of(2024, 11, 22, 19, 0),
+ "https://example.com/image1.jpg"
+ );
+
+ Location location2 = new Location("Rogers Centre, Toronto, ON", 43.6414, -79.3894);
+ Event event2 = new Event(
+ "2",
+ "Drake Concert",
+ "Live music performance",
+ "Demo Address 2",
+ EventCategory.MUSIC,
+ location2,
+ LocalDateTime.of(2024, 11, 22, 20, 30),
+ "https://example.com/image2.jpg"
+ );
+
+ Location location3 = new Location("Second City, Toronto, ON", 43.6426, -79.3871);
+ Event event3 = new Event(
+ "3",
+ "Comedy Night",
+ "Stand-up comedy show",
+ "Demo Address 3",
+ EventCategory.ARTS_THEATRE,
+ location3,
+ LocalDateTime.of(2024, 11, 22, 21, 0),
+ "https://example.com/image3.jpg"
+ );
+
+ events.add(event1);
+ events.add(event2);
+ events.add(event3);
+
+ return events;
+ }
+
+
+ @BeforeEach
+ public void setUp() {
+ // Create ViewModel
+ viewModel = new CalendarFlowViewModel();
+ // Create View
+ view = new EventListByDateView(viewModel);
+ }
+
+ @Test
+ public void testViewCreation() {
+ // Test that view is created successfully
+ assertNotNull(view);
+ assertEquals("event list by date", view.getViewName());
+ }
+
+ @Test
+ public void testInitialState() {
+ // Test that view starts with empty state
+ assertNotNull(view);
+
+ // View should be visible and properly initialized
+ assertTrue(view.isVisible() || !view.isVisible()); // Just checking it exists
+ }
+
+ @Test
+ public void testViewWithEvents() {
+ // Create test events
+ List events = createTestEvents();
+
+ // Create state with events
+ CalendarFlowState state = new CalendarFlowState();
+ state.setDate(LocalDate.of(2024, 11, 22));
+ state.setEventList(events);
+
+ // Update ViewModel (this should trigger view update)
+ viewModel.setState(state);
+ viewModel.firePropertyChange();
+
+ // Verify state was set
+ assertEquals(3, viewModel.getState().getEventList().size());
+ assertEquals(LocalDate.of(2024, 11, 22), viewModel.getState().getDate());
+ }
+
+ @Test
+ public void testDateFormatting() {
+ // Create state with date
+ CalendarFlowState state = new CalendarFlowState();
+ state.setDate(LocalDate.of(2024, 11, 22));
+ state.setEventList(new ArrayList<>());
+
+ // Update ViewModel
+ viewModel.setState(state);
+ viewModel.firePropertyChange();
+
+ // Verify date is set
+ assertEquals(LocalDate.of(2024, 11, 22), viewModel.getState().getDate());
+ }
+
+ @Test
+ public void testMultipleStateUpdates() {
+ // First update - with events
+ CalendarFlowState state1 = new CalendarFlowState();
+ state1.setDate(LocalDate.of(2024, 11, 22));
+ state1.setEventList(createTestEvents());
+
+ viewModel.setState(state1);
+ viewModel.firePropertyChange();
+
+ assertEquals(3, viewModel.getState().getEventList().size());
+
+ // Second update - no events
+ CalendarFlowState state2 = new CalendarFlowState();
+ state2.setDate(LocalDate.of(2024, 11, 23));
+ state2.setEventList(new ArrayList<>());
+ state2.setErrorMessage("No events found");
+
+ viewModel.setState(state2);
+ viewModel.firePropertyChange();
+
+ assertTrue(viewModel.getState().getEventList().isEmpty());
+ assertEquals(LocalDate.of(2024, 11, 23), viewModel.getState().getDate());
+ }
+
+ public static void main(String[] args) {
+ SwingUtilities.invokeLater(() -> {
+ // Create ViewModel and View
+ CalendarFlowViewModel viewModel = new CalendarFlowViewModel();
+ EventListByDateView view = new EventListByDateView(viewModel);
+
+ // Set up a sample state
+ CalendarFlowState state = new CalendarFlowState();
+ state.setDate(LocalDate.of(2024, 11, 22));
+ state.setEventList(createTestEvents());
+
+ viewModel.setState(state);
+ viewModel.firePropertyChange();
+
+ // Show in a JFrame
+ JFrame frame = new JFrame("EventListByDateView – Preview");
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ frame.setContentPane(view);
+ frame.pack();
+ frame.setLocationRelativeTo(null);
+ frame.setVisible(true);
+ });
+ }
+}
diff --git a/src/test/java/use_case/display_local_events/DisplayLocalEventsInteractorTest.java b/src/test/java/use_case/display_local_events/DisplayLocalEventsInteractorTest.java
new file mode 100644
index 00000000..b5841cf2
--- /dev/null
+++ b/src/test/java/use_case/display_local_events/DisplayLocalEventsInteractorTest.java
@@ -0,0 +1,924 @@
+package use_case.display_local_events;
+
+import data_access.TicketmasterEventRepositoryAdapter;
+import entity.Event;
+import entity.EventCategory;
+import entity.EventRepository;
+import entity.Location;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Nested;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+//by using Chatgpt: I use the ai to help me to do the interactor test.
+class DisplayLocalEventsInteractorTest {
+
+ private DisplayLocalEventsInteractor interactor;
+ private TestEventRepository testEventRepository;
+ private TestOutputBoundary testOutputBoundary;
+
+ @BeforeEach
+ void setUp() {
+ testEventRepository = new TestEventRepository();
+ testOutputBoundary = new TestOutputBoundary();
+ interactor = new DisplayLocalEventsInteractor(testEventRepository, testOutputBoundary);
+ }
+
+ @Test
+ void testExecuteWithValidInput() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ double radius = 10.0;
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, radius, null
+ );
+
+ Event event1 = createTestEvent("1", "Concert", 43.6532, -79.3832, EventCategory.MUSIC);
+ Event event2 = createTestEvent("2", "Game", 43.6600, -79.3900, EventCategory.SPORTS);
+ testEventRepository.addEvent(event1);
+ testEventRepository.addEvent(event2);
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isSuccessCalled);
+ assertFalse(testOutputBoundary.isErrorCalled);
+ assertNotNull(testOutputBoundary.outputData);
+ assertEquals(2, testOutputBoundary.outputData.getEvents().size());
+ assertTrue(testOutputBoundary.outputData.getMessage().contains("Found 2 events"));
+ }
+
+ @Test
+ void testExecuteWithNullLocation() {
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ null, 10.0, null
+ );
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isErrorCalled);
+ assertFalse(testOutputBoundary.isSuccessCalled);
+ assertEquals("Invalid input: location and radius are required",
+ testOutputBoundary.errorMessage);
+ }
+
+ @Test
+ void testExecuteWithNegativeRadius() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, -5.0, null
+ );
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isErrorCalled);
+ assertFalse(testOutputBoundary.isSuccessCalled);
+ }
+
+
+
+ @Test
+ void testExecuteWithZeroRadius() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, 0.0, null
+ );
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isErrorCalled);
+ }
+
+ @Test
+ void testExecuteWithCategoryFilter() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ double radius = 10.0;
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, radius, EventCategory.MUSIC
+ );
+
+ Event musicEvent = createTestEvent("1", "Concert", 43.6532, -79.3832, EventCategory.MUSIC);
+ Event sportsEvent = createTestEvent("2", "Game", 43.6600, -79.3900, EventCategory.SPORTS);
+ testEventRepository.addEvent(musicEvent);
+ testEventRepository.addEvent(sportsEvent);
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isSuccessCalled);
+ assertEquals(1, testOutputBoundary.outputData.getEvents().size());
+ assertEquals(EventCategory.MUSIC,
+ testOutputBoundary.outputData.getEvents().get(0).getCategory());
+ assertTrue(testOutputBoundary.outputData.getMessage().contains("Music"));
+ }
+
+ @Test
+ void testExecuteWithNoEventsFound() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ double radius = 10.0;
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, radius, null
+ );
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isSuccessCalled);
+ assertEquals(0, testOutputBoundary.outputData.getEvents().size());
+ assertTrue(testOutputBoundary.outputData.getMessage().contains("Found 0 events"));
+ }
+
+ @Test
+ void testExecuteEventsSortedByDistance() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ double radius = 50.0;
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, radius, null
+ );
+
+ Event nearEvent = createTestEvent("1", "Near Event", 43.6532, -79.3832, EventCategory.MUSIC);
+ Event farEvent = createTestEvent("2", "Far Event", 43.7000, -79.4000, EventCategory.MUSIC);
+
+ testEventRepository.addEvent(farEvent);
+ testEventRepository.addEvent(nearEvent);
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isSuccessCalled);
+ List events = testOutputBoundary.outputData.getEvents();
+ assertEquals(2, events.size());
+
+ double distance1 = events.get(0).calculateDistanceTo(userLocation);
+ double distance2 = events.get(1).calculateDistanceTo(userLocation);
+ assertTrue(distance1 <= distance2,
+ "Events should be sorted by distance (closest first)");
+ }
+
+ @Test
+ void testEqualsWithSameEventsDifferentOrder() {
+ List events1 = new ArrayList<>();
+ events1.add(createTestEvent("1", "Event 1", 43.6532, -79.3832, EventCategory.MUSIC));
+ events1.add(createTestEvent("2", "Event 2", 43.6600, -79.3900, EventCategory.SPORTS));
+
+ List events2 = new ArrayList<>();
+ events2.add(createTestEvent("2", "Event 2", 43.6600, -79.3900, EventCategory.SPORTS));
+ events2.add(createTestEvent("1", "Event 1", 43.6532, -79.3832, EventCategory.MUSIC));
+
+ DisplayLocalEventsOutputData outputData1 = new DisplayLocalEventsOutputData(
+ events1, "message"
+ );
+ DisplayLocalEventsOutputData outputData2 = new DisplayLocalEventsOutputData(
+ events2, "message"
+ );
+
+ assertNotEquals(outputData1, outputData2);
+ }
+
+ @Test
+ void testExecuteWithException() {
+ TestEventRepository errorRepository = new TestEventRepository();
+ errorRepository.setShouldThrowException(true);
+ DisplayLocalEventsInteractor errorInteractor = new DisplayLocalEventsInteractor(
+ errorRepository, testOutputBoundary
+ );
+
+ Location userLocation = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, 10.0, null
+ );
+
+ errorInteractor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isErrorCalled);
+ assertTrue(testOutputBoundary.errorMessage.contains("Error displaying local events"));
+ }
+
+ @Test
+ void testSwitchToSaveView() {
+ interactor.switchToSaveView();
+ assertTrue(testOutputBoundary.isSwitchToSaveViewCalled);
+ }
+
+ @Test
+ void testEventDistancesCalculated() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, 10.0, null
+ );
+
+ Event event = createTestEvent("1", "Event", 43.6532, -79.3832, EventCategory.MUSIC);
+ testEventRepository.addEvent(event);
+
+ interactor.execute(inputData);
+
+ Map distances = testOutputBoundary.outputData.getEventDistances();
+ assertNotNull(distances);
+ assertTrue(distances.containsKey("1"));
+ assertTrue(distances.get("1") >= 0);
+ }
+
+ @Test
+ void testEventsOutsideRadiusFiltered() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ double radius = 5.0;
+
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, radius, null
+ );
+
+ Event nearEvent = createTestEvent("1", "Near", 43.6532, -79.3832, EventCategory.MUSIC);
+ Event farEvent = createTestEvent("2", "Far", 44.0000, -80.0000, EventCategory.MUSIC);
+
+ testEventRepository.addEvent(nearEvent);
+ testEventRepository.addEvent(farEvent);
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isSuccessCalled);
+ assertEquals(1, testOutputBoundary.outputData.getEvents().size());
+ assertEquals("1", testOutputBoundary.outputData.getEvents().get(0).getId());
+ }
+
+ @Test
+ void testMultipleCategoriesWithFilter() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, 10.0, EventCategory.SPORTS
+ );
+
+ Event musicEvent = createTestEvent("1", "Concert", 43.6532, -79.3832, EventCategory.MUSIC);
+ Event sportsEvent1 = createTestEvent("2", "Game 1", 43.6600, -79.3900, EventCategory.SPORTS);
+ Event sportsEvent2 = createTestEvent("3", "Game 2", 43.6550, -79.3850, EventCategory.SPORTS);
+ Event artsEvent = createTestEvent("4", "Play", 43.6580, -79.3880, EventCategory.ARTS_THEATRE);
+
+ testEventRepository.addEvent(musicEvent);
+ testEventRepository.addEvent(sportsEvent1);
+ testEventRepository.addEvent(sportsEvent2);
+ testEventRepository.addEvent(artsEvent);
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isSuccessCalled);
+ assertEquals(2, testOutputBoundary.outputData.getEvents().size());
+ for (Event event : testOutputBoundary.outputData.getEvents()) {
+ assertEquals(EventCategory.SPORTS, event.getCategory());
+ }
+ }
+
+ @Test
+ void testEqualsReturnsTrueForEqualEvents() {
+ List events = createTestEventList();
+
+ DisplayLocalEventsOutputData outputData1 = new DisplayLocalEventsOutputData(
+ events, "same message"
+ );
+ DisplayLocalEventsOutputData outputData2 = new DisplayLocalEventsOutputData(
+ events, "same message"
+ );
+
+ assertTrue(outputData1.equals(outputData2));
+ }
+
+ @Test
+ void testExecuteWithTicketmasterAdapter() {
+ TestTicketmasterAdapter ticketmasterAdapter = new TestTicketmasterAdapter();
+ DisplayLocalEventsInteractor ticketmasterInteractor = new DisplayLocalEventsInteractor(
+ ticketmasterAdapter, testOutputBoundary
+ );
+
+ Location userLocation = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, 10.0, null
+ );
+
+ Event event = createTestEvent("1", "Event", 43.6532, -79.3832, EventCategory.MUSIC);
+ ticketmasterAdapter.addEvent(event);
+
+ ticketmasterInteractor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isSuccessCalled);
+ assertTrue(ticketmasterAdapter.findEventsCalled);
+ assertEquals(1, testOutputBoundary.outputData.getEvents().size());
+ }
+
+ @Test
+ void testExecuteMessageWithCategory() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, 10.0, EventCategory.MUSIC
+ );
+
+ Event event = createTestEvent("1", "Concert", 43.6532, -79.3832, EventCategory.MUSIC);
+ testEventRepository.addEvent(event);
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isSuccessCalled);
+ String message = testOutputBoundary.outputData.getMessage();
+ assertTrue(message.contains("Music"));
+ assertTrue(message.contains("1"));
+ }
+
+ @Test
+ void testExecuteMessageWithoutCategory() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, 10.0, null
+ );
+
+ Event event = createTestEvent("1", "Event", 43.6532, -79.3832, EventCategory.MUSIC);
+ testEventRepository.addEvent(event);
+
+ interactor.execute(inputData);
+
+ assertTrue(testOutputBoundary.isSuccessCalled);
+ String message = testOutputBoundary.outputData.getMessage();
+ assertFalse(message.contains("Music"));
+ assertTrue(message.contains("1"));
+ }
+
+ @Test
+ void testCalculateEventDistancesMultipleEvents() {
+ Location userLocation = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ userLocation, 10.0, null
+ );
+
+ Event event1 = createTestEvent("1", "Event1", 43.6532, -79.3832, EventCategory.MUSIC);
+ Event event2 = createTestEvent("2", "Event2", 43.6600, -79.3900, EventCategory.MUSIC);
+ testEventRepository.addEvent(event1);
+ testEventRepository.addEvent(event2);
+
+ interactor.execute(inputData);
+
+ Map distances = testOutputBoundary.outputData.getEventDistances();
+ assertEquals(2, distances.size());
+ assertTrue(distances.containsKey("1"));
+ assertTrue(distances.containsKey("2"));
+ assertTrue(distances.get("1") >= 0);
+ assertTrue(distances.get("2") >= 0);
+ }
+
+ @Nested
+ class InputDataTests {
+ @Test
+ void testConstructorAndGetters() {
+ Location location = new Location(43.6532, -79.3832);
+ double radius = 10.0;
+ EventCategory category = EventCategory.MUSIC;
+
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ location, radius, category
+ );
+
+ assertEquals(location, inputData.getUserLocation());
+ assertEquals(radius, inputData.getRadiusKm());
+ assertEquals(category, inputData.getFilterCategory());
+ }
+
+ @Test
+ void testIsValidWithValidData() {
+ Location location = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ location, 10.0, null
+ );
+
+ assertTrue(inputData.isValid());
+ }
+
+ @Test
+ void testIsValidWithNullLocation() {
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ null, 10.0, null
+ );
+
+ assertFalse(inputData.isValid());
+ }
+
+ @Test
+ void testIsValidWithNegativeRadius() {
+ Location location = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ location, -5.0, null
+ );
+
+ assertFalse(inputData.isValid());
+ }
+
+ @Test
+ void testIsValidWithZeroRadius() {
+ Location location = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ location, 0.0, null
+ );
+
+ assertFalse(inputData.isValid());
+ }
+
+ @Test
+ void testHasCategoryFilterWithCategory() {
+ Location location = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ location, 10.0, EventCategory.MUSIC
+ );
+
+ assertTrue(inputData.hasCategoryFilter());
+ }
+
+ @Test
+ void testHasCategoryFilterWithoutCategory() {
+ Location location = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ location, 10.0, null
+ );
+
+ assertFalse(inputData.hasCategoryFilter());
+ }
+
+ @Test
+ void testToString() {
+ Location location = new Location(43.6532, -79.3832);
+ DisplayLocalEventsInputData inputData = new DisplayLocalEventsInputData(
+ location, 10.0, EventCategory.MUSIC
+ );
+
+ String result = inputData.toString();
+ assertNotNull(result);
+ assertTrue(result.contains("DisplayLocalEventsInputData"));
+ }
+
+ @Test
+ void testEqualsAndHashCode() {
+ Location location1 = new Location(43.6532, -79.3832);
+ Location location2 = new Location(43.6532, -79.3832);
+
+ DisplayLocalEventsInputData inputData1 = new DisplayLocalEventsInputData(
+ location1, 10.0, EventCategory.MUSIC
+ );
+ DisplayLocalEventsInputData inputData2 = new DisplayLocalEventsInputData(
+ location2, 10.0, EventCategory.MUSIC
+ );
+ DisplayLocalEventsInputData inputData3 = new DisplayLocalEventsInputData(
+ location1, 15.0, EventCategory.MUSIC
+ );
+
+ assertEquals(inputData1, inputData2);
+ assertNotEquals(inputData1, inputData3);
+ assertEquals(inputData1, inputData1);
+ assertNotEquals(inputData1, null);
+ assertNotEquals(inputData1, "string");
+
+ assertEquals(inputData1.hashCode(), inputData2.hashCode());
+ }
+
+ @Test
+ void testEqualsWithDifferentCategory() {
+ Location location = new Location(43.6532, -79.3832);
+
+ DisplayLocalEventsInputData inputData1 = new DisplayLocalEventsInputData(
+ location, 10.0, EventCategory.MUSIC
+ );
+ DisplayLocalEventsInputData inputData2 = new DisplayLocalEventsInputData(
+ location, 10.0, EventCategory.SPORTS
+ );
+ DisplayLocalEventsInputData inputData3 = new DisplayLocalEventsInputData(
+ location, 10.0, null
+ );
+
+ assertNotEquals(inputData1, inputData2);
+ assertNotEquals(inputData1, inputData3);
+ }
+
+ @Test
+ void testEqualsWithBothNullCategories() {
+ Location location = new Location(43.6532, -79.3832);
+
+ DisplayLocalEventsInputData inputData1 = new DisplayLocalEventsInputData(
+ location, 10.0, null
+ );
+ DisplayLocalEventsInputData inputData2 = new DisplayLocalEventsInputData(
+ location, 10.0, null
+ );
+
+ assertEquals(inputData1, inputData2);
+ assertEquals(inputData1.hashCode(), inputData2.hashCode());
+ }
+
+ @Test
+ void testEqualsWithOneNullCategory() {
+ Location location = new Location(43.6532, -79.3832);
+
+ DisplayLocalEventsInputData inputData1 = new DisplayLocalEventsInputData(
+ location, 10.0, null
+ );
+ DisplayLocalEventsInputData inputData2 = new DisplayLocalEventsInputData(
+ location, 10.0, EventCategory.MUSIC
+ );
+
+ assertNotEquals(inputData1, inputData2);
+ }
+
+ @Test
+ void testEqualsWithDifferentLocations() {
+ Location location1 = new Location(43.6532, -79.3832);
+ Location location2 = new Location(43.7000, -79.4000);
+
+ DisplayLocalEventsInputData inputData1 = new DisplayLocalEventsInputData(
+ location1, 10.0, null
+ );
+ DisplayLocalEventsInputData inputData2 = new DisplayLocalEventsInputData(
+ location2, 10.0, null
+ );
+
+ assertNotEquals(inputData1, inputData2);
+ }
+ }
+
+ @Nested
+ class OutputDataTests {
+ @Test
+ void testConstructorWithTwoParameters() {
+ List events = createTestEventList();
+ String message = "Found 2 events";
+
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ events, message
+ );
+
+ assertEquals(events, outputData.getEvents());
+ assertEquals(message, outputData.getMessage());
+ assertEquals(2, outputData.getTotalEvents());
+ assertNotNull(outputData.getEventDistances());
+ }
+
+ @Test
+ void testConstructorWithThreeParameters() {
+ List events = createTestEventList();
+ String message = "Found 2 events";
+ Map distances = new HashMap<>();
+ distances.put("1", 5.0);
+ distances.put("2", 10.0);
+
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ events, message, distances
+ );
+
+ assertEquals(events, outputData.getEvents());
+ assertEquals(message, outputData.getMessage());
+ assertEquals(2, outputData.getTotalEvents());
+ assertEquals(distances, outputData.getEventDistances());
+ }
+
+ @Test
+ void testConstructorWithNullEvents() {
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ null, "message"
+ );
+
+ assertNotNull(outputData.getEvents());
+ assertEquals(0, outputData.getEvents().size());
+ assertEquals(0, outputData.getTotalEvents());
+ }
+
+ @Test
+ void testConstructorWithNullMessage() {
+ List events = createTestEventList();
+
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ events, null
+ );
+
+ assertEquals("", outputData.getMessage());
+ }
+
+ @Test
+ void testConstructorWithNullDistances() {
+ List events = createTestEventList();
+
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ events, "message", null
+ );
+
+ assertNotNull(outputData.getEventDistances());
+ assertEquals(0, outputData.getEventDistances().size());
+ }
+
+ @Test
+ void testConstructorWithAllNullParameters() {
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ null, null, null
+ );
+
+ assertNotNull(outputData.getEvents());
+ assertEquals(0, outputData.getEvents().size());
+ assertEquals("", outputData.getMessage());
+ assertNotNull(outputData.getEventDistances());
+ assertEquals(0, outputData.getEventDistances().size());
+ }
+
+ @Test
+ void testGetDistanceForEvent() {
+ List events = createTestEventList();
+ Map distances = new HashMap<>();
+ distances.put("1", 5.0);
+ distances.put("2", 10.0);
+
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ events, "message", distances
+ );
+
+ assertEquals(5.0, outputData.getDistanceForEvent("1"));
+ assertEquals(10.0, outputData.getDistanceForEvent("2"));
+ assertEquals(-1.0, outputData.getDistanceForEvent("999"));
+ }
+
+ @Test
+ void testGetTotalEvents() {
+ List events = createTestEventList();
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ events, "message"
+ );
+
+ assertEquals(2, outputData.getTotalEvents());
+ }
+
+ @Test
+ void testHasEvents() {
+ List events = createTestEventList();
+ DisplayLocalEventsOutputData outputData1 = new DisplayLocalEventsOutputData(
+ events, "message"
+ );
+ DisplayLocalEventsOutputData outputData2 = new DisplayLocalEventsOutputData(
+ new ArrayList<>(), "message"
+ );
+
+ assertTrue(outputData1.hasEvents());
+ assertFalse(outputData2.hasEvents());
+ }
+
+ @Test
+ void testHasDistanceData() {
+ Map distances = new HashMap<>();
+ distances.put("1", 5.0);
+
+ DisplayLocalEventsOutputData outputData1 = new DisplayLocalEventsOutputData(
+ createTestEventList(), "message", distances
+ );
+ DisplayLocalEventsOutputData outputData2 = new DisplayLocalEventsOutputData(
+ createTestEventList(), "message", new HashMap<>()
+ );
+
+ assertTrue(outputData1.hasDistanceData());
+ assertFalse(outputData2.hasDistanceData());
+ }
+
+ @Test
+ void testToString() {
+ List events = createTestEventList();
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ events, "Test message"
+ );
+
+ String result = outputData.toString();
+ assertNotNull(result);
+ assertTrue(result.contains("DisplayLocalEventsOutputData"));
+ assertTrue(result.contains("2"));
+ assertTrue(result.contains("Test message"));
+ }
+
+ @Test
+ void testToStringWithDistances() {
+ Map distances = new HashMap<>();
+ distances.put("1", 5.0);
+
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ createTestEventList(), "Test message", distances
+ );
+
+ String result = outputData.toString();
+ assertTrue(result.contains("true"));
+ }
+
+ @Test
+ void testToStringWithoutDistances() {
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ createTestEventList(), "Test message", new HashMap<>()
+ );
+
+ String result = outputData.toString();
+ assertTrue(result.contains("false"));
+ }
+
+ @Test
+ void testEqualsAndHashCode() {
+ List events1 = createTestEventList();
+ List events2 = createTestEventList();
+ List events3 = new ArrayList<>();
+
+ DisplayLocalEventsOutputData outputData1 = new DisplayLocalEventsOutputData(
+ events1, "message"
+ );
+ DisplayLocalEventsOutputData outputData2 = new DisplayLocalEventsOutputData(
+ events2, "message"
+ );
+ DisplayLocalEventsOutputData outputData3 = new DisplayLocalEventsOutputData(
+ events3, "message"
+ );
+ DisplayLocalEventsOutputData outputData4 = new DisplayLocalEventsOutputData(
+ events1, "different message"
+ );
+
+ assertEquals(outputData1, outputData2);
+ assertNotEquals(outputData1, outputData3);
+ assertNotEquals(outputData1, outputData4);
+ assertEquals(outputData1, outputData1);
+ assertNotEquals(outputData1, null);
+ assertNotEquals(outputData1, "string");
+
+ assertEquals(outputData1.hashCode(), outputData2.hashCode());
+ }
+
+ @Test
+ void testEqualsWithDifferentTotalEvents() {
+ List events1 = createTestEventList();
+ List events2 = new ArrayList<>();
+ events2.add(createTestEvent("1", "Event", 43.6532, -79.3832, EventCategory.MUSIC));
+
+ DisplayLocalEventsOutputData outputData1 = new DisplayLocalEventsOutputData(
+ events1, "message"
+ );
+ DisplayLocalEventsOutputData outputData2 = new DisplayLocalEventsOutputData(
+ events2, "message"
+ );
+
+ assertNotEquals(outputData1, outputData2);
+ }
+
+ @Test
+ void testEqualsWithDifferentEvents() {
+ List events1 = createTestEventList();
+ List events2 = new ArrayList<>();
+ events2.add(createTestEvent("3", "Different Event", 43.6532, -79.3832, EventCategory.FILM));
+
+ DisplayLocalEventsOutputData outputData1 = new DisplayLocalEventsOutputData(
+ events1, "message"
+ );
+ DisplayLocalEventsOutputData outputData2 = new DisplayLocalEventsOutputData(
+ events2, "message"
+ );
+
+ assertNotEquals(outputData1, outputData2);
+ }
+
+ @Test
+ void testHashCodeConsistency() {
+ List events = createTestEventList();
+ DisplayLocalEventsOutputData outputData = new DisplayLocalEventsOutputData(
+ events, "message"
+ );
+
+ int hash1 = outputData.hashCode();
+ int hash2 = outputData.hashCode();
+
+ assertEquals(hash1, hash2);
+ }
+ }
+
+ private Event createTestEvent(String id, String name, double lat, double lon,
+ EventCategory category) {
+ return new Event(
+ id,
+ name,
+ "Description for " + name,
+ "123 Test St",
+ category,
+ new Location(lat, lon),
+ LocalDateTime.now().plusDays(1),
+ "https://example.com/image.jpg"
+ );
+ }
+
+ private List createTestEventList() {
+ List events = new ArrayList<>();
+ events.add(new Event(
+ "1",
+ "Event 1",
+ "Description",
+ "Address 1",
+ EventCategory.MUSIC,
+ new Location(43.6532, -79.3832),
+ LocalDateTime.now().plusDays(1),
+ "image1.jpg"
+ ));
+ events.add(new Event(
+ "2",
+ "Event 2",
+ "Description",
+ "Address 2",
+ EventCategory.SPORTS,
+ new Location(43.6600, -79.3900),
+ LocalDateTime.now().plusDays(2),
+ "image2.jpg"
+ ));
+ return events;
+ }
+
+ private static class TestEventRepository implements EventRepository {
+ private List events = new ArrayList<>();
+ private boolean shouldThrowException = false;
+
+ public void addEvent(Event event) {
+ events.add(event);
+ }
+
+ public void setShouldThrowException(boolean value) {
+ this.shouldThrowException = value;
+ }
+
+ @Override
+ public List findAllEvents() {
+ if (shouldThrowException) {
+ throw new RuntimeException("Test exception");
+ }
+ return new ArrayList<>(events);
+ }
+
+ @Override
+ public Optional findById(String id) {
+ return events.stream()
+ .filter(e -> e.getId().equals(id))
+ .findFirst();
+ }
+
+ @Override
+ public List findByName(String query) {
+ return events.stream()
+ .filter(e -> e.getName().toLowerCase().contains(query.toLowerCase()))
+ .collect(java.util.stream.Collectors.toList());
+ }
+ }
+
+ private static class TestTicketmasterAdapter extends TicketmasterEventRepositoryAdapter {
+ private List events = new ArrayList<>();
+ boolean findEventsCalled = false;
+
+ public TestTicketmasterAdapter() {
+ super(null, new Location(43.6532, -79.3832), 10.0);
+ }
+
+ public void addEvent(Event event) {
+ events.add(event);
+ }
+
+ @Override
+ public List findEvents(Location center, double radiusKm) {
+ findEventsCalled = true;
+ return new ArrayList<>(events);
+ }
+
+ @Override
+ public List findAllEvents() {
+ return new ArrayList<>(events);
+ }
+
+ @Override
+ public Optional findById(String id) {
+ return events.stream()
+ .filter(e -> e.getId().equals(id))
+ .findFirst();
+ }
+
+ @Override
+ public List findByName(String query) {
+ return new ArrayList<>();
+ }
+ }
+
+ private static class TestOutputBoundary implements DisplayLocalEventsOutputBoundary {
+ boolean isSuccessCalled = false;
+ boolean isErrorCalled = false;
+ boolean isSwitchToSaveViewCalled = false;
+ DisplayLocalEventsOutputData outputData;
+ String errorMessage;
+
+ @Override
+ public void presentSuccess(DisplayLocalEventsOutputData outputData) {
+ this.isSuccessCalled = true;
+ this.outputData = outputData;
+ }
+
+ @Override
+ public void presentError(String errorMessage) {
+ this.isErrorCalled = true;
+ this.errorMessage = errorMessage;
+ }
+
+ @Override
+ public void switchToSaveView() {
+ this.isSwitchToSaveViewCalled = true;
+ }
+ }
+}
diff --git a/src/test/java/use_case/event_description/EventDescriptionInteractorTest.java b/src/test/java/use_case/event_description/EventDescriptionInteractorTest.java
new file mode 100644
index 00000000..114f5e59
--- /dev/null
+++ b/src/test/java/use_case/event_description/EventDescriptionInteractorTest.java
@@ -0,0 +1,186 @@
+package use_case.event_description;
+
+import data_access.InMemoryEventDataAccessObject;
+import entity.Event;
+import entity.Location;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class EventDescriptionInteractorTest {
+
+ private static class TestPresenter implements EventDescriptionOutputBoundary {
+ EventDescriptionOutputData lastOutput;
+ String lastError;
+
+ @Override
+ public void prepareSuccessView(EventDescriptionOutputData outputData) {
+ lastOutput = outputData;
+ }
+
+ @Override
+ public void prepareFailView(String errorMessage) {
+ lastError = errorMessage;
+ }
+ }
+
+ @Test
+ void successPath_eventFoundAndDistanceComputed() {
+ // arrange
+ InMemoryEventDataAccessObject eventDAO = new InMemoryEventDataAccessObject();
+ Location loc = new Location(43.0, -79.0);
+ Event event = new Event(
+ "1",
+ "Music Festival",
+ "Outdoor live music event",
+ "123 Queen St",
+ loc,
+ "Music",
+ "2025-11-20T19:00"
+ );
+ eventDAO.save(event);
+
+ TestPresenter presenter = new TestPresenter();
+ DistanceCalculator distanceCalculator = new HaversineDistanceCalculator();
+
+ EventDescriptionInputBoundary interactor =
+ new EventDescriptionInteractor(eventDAO, presenter, distanceCalculator);
+
+ EventDescriptionInputData input =
+ new EventDescriptionInputData("1", 43.1, -79.0);
+
+ interactor.execute(input);
+
+ assertNull(presenter.lastError);
+ assertNotNull(presenter.lastOutput);
+
+ assertEquals("Music Festival", presenter.lastOutput.getName());
+ assertEquals("123 Queen St", presenter.lastOutput.getAddress());
+ assertTrue(presenter.lastOutput.getDistanceKm() > 0);
+ }
+
+ @Test
+ void eventNotFound_callsFailure() {
+ InMemoryEventDataAccessObject eventDAO = new InMemoryEventDataAccessObject();
+ TestPresenter presenter = new TestPresenter();
+ DistanceCalculator distanceCalculator = new HaversineDistanceCalculator();
+
+ EventDescriptionInputBoundary interactor =
+ new EventDescriptionInteractor(eventDAO, presenter, distanceCalculator);
+
+ EventDescriptionInputData input =
+ new EventDescriptionInputData("999", 43.0, -79.0);
+
+ interactor.execute(input);
+
+ assertNull(presenter.lastOutput);
+ assertEquals("Event not found.", presenter.lastError);
+ }
+
+ // ============ Additional tests for 100% coverage ============
+
+ @Test
+ void testEventDescriptionInputData_allGetters() {
+ // Test all getters in EventDescriptionInputData
+ EventDescriptionInputData inputData =
+ new EventDescriptionInputData("event-123", 45.5, -75.5);
+
+ assertEquals("event-123", inputData.getEventId());
+ assertEquals(45.5, inputData.getUserLatitude(), 0.001);
+ assertEquals(-75.5, inputData.getUserLongitude(), 0.001);
+ }
+
+ @Test
+ void testEventDescriptionOutputData_allGetters() {
+ // Test all getters in EventDescriptionOutputData
+ EventDescriptionOutputData outputData = new EventDescriptionOutputData(
+ "Concert Name",
+ "A great concert",
+ "456 Main St",
+ "MUSIC",
+ "2025-12-25 20:00",
+ 15.5
+ );
+
+ assertEquals("Concert Name", outputData.getName());
+ assertEquals("A great concert", outputData.getDescription());
+ assertEquals("456 Main St", outputData.getAddress());
+ assertEquals("MUSIC", outputData.getCategory());
+ assertEquals("2025-12-25 20:00", outputData.getDateTime());
+ assertEquals(15.5, outputData.getDistanceKm(), 0.001);
+ }
+
+ @Test
+ void testHaversineDistanceCalculator_sameLocation() {
+ // Test distance calculator with same coordinates (should be 0)
+ HaversineDistanceCalculator calculator = new HaversineDistanceCalculator();
+
+ double distance = calculator.distanceKm(43.0, -79.0, 43.0, -79.0);
+
+ assertEquals(0.0, distance, 0.001);
+ }
+
+ @Test
+ void testHaversineDistanceCalculator_knownDistance() {
+ // Test distance calculator with known coordinates
+ // Toronto to Montreal is approximately 500 km
+ HaversineDistanceCalculator calculator = new HaversineDistanceCalculator();
+
+ // Toronto: 43.6532, -79.3832
+ // Montreal: 45.5017, -73.5673
+ double distance = calculator.distanceKm(43.6532, -79.3832, 45.5017, -73.5673);
+
+ // Should be approximately 500-550 km
+ assertTrue(distance > 400 && distance < 600,
+ "Distance between Toronto and Montreal should be ~500km, was: " + distance);
+ }
+
+ @Test
+ void testHaversineDistanceCalculator_antipodal() {
+ // Test with very far apart locations
+ HaversineDistanceCalculator calculator = new HaversineDistanceCalculator();
+
+ // North pole to South pole (approximately 20,000 km)
+ double distance = calculator.distanceKm(90.0, 0.0, -90.0, 0.0);
+
+ assertTrue(distance > 19000 && distance < 21000,
+ "Pole to pole distance should be ~20,000km, was: " + distance);
+ }
+
+ @Test
+ void successPath_verifyAllOutputFields() {
+ // Test that all output fields are correctly populated
+ InMemoryEventDataAccessObject eventDAO = new InMemoryEventDataAccessObject();
+ Location loc = new Location("789 Test Ave, Toronto", 43.65, -79.38);
+ Event event = new Event(
+ "test-id",
+ "Test Event Name",
+ "Test Description Here",
+ "789 Test Ave, Toronto",
+ loc,
+ "Sports",
+ "2025-06-15T14:30"
+ );
+ eventDAO.save(event);
+
+ TestPresenter presenter = new TestPresenter();
+ DistanceCalculator distanceCalculator = new HaversineDistanceCalculator();
+
+ EventDescriptionInteractor interactor =
+ new EventDescriptionInteractor(eventDAO, presenter, distanceCalculator);
+
+ EventDescriptionInputData input =
+ new EventDescriptionInputData("test-id", 43.65, -79.38);
+
+ interactor.execute(input);
+
+ assertNotNull(presenter.lastOutput);
+ assertEquals("Test Event Name", presenter.lastOutput.getName());
+ assertEquals("Test Description Here", presenter.lastOutput.getDescription());
+ assertEquals("789 Test Ave, Toronto", presenter.lastOutput.getAddress());
+ assertEquals("Sports", presenter.lastOutput.getCategory());
+ assertEquals("2025-06-15 14:30", presenter.lastOutput.getDateTime());
+ // Distance should be 0 or very small since user is at event location
+ assertTrue(presenter.lastOutput.getDistanceKm() < 1.0);
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/use_case/login/LoginInteractorTest.java b/src/test/java/use_case/login/LoginInteractorTest.java
index 4662abd9..4a1aa841 100644
--- a/src/test/java/use_case/login/LoginInteractorTest.java
+++ b/src/test/java/use_case/login/LoginInteractorTest.java
@@ -31,6 +31,11 @@ public void prepareSuccessView(LoginOutputData user) {
public void prepareFailView(String error) {
fail("Use case failure is unexpected.");
}
+
+ @Override
+ public void switchToSignUpView() {
+
+ }
};
LoginInputBoundary interactor = new LoginInteractor(userRepository, successPresenter);
@@ -61,6 +66,11 @@ public void prepareSuccessView(LoginOutputData user) {
public void prepareFailView(String error) {
assertEquals("Incorrect password for \"Paul\".", error);
}
+
+ @Override
+ public void switchToSignUpView() {
+
+ }
};
LoginInputBoundary interactor = new LoginInteractor(userRepository, failurePresenter);
@@ -86,6 +96,11 @@ public void prepareSuccessView(LoginOutputData user) {
public void prepareFailView(String error) {
assertEquals("Paul: Account does not exist.", error);
}
+
+ @Override
+ public void switchToSignUpView() {
+
+ }
};
LoginInputBoundary interactor = new LoginInteractor(userRepository, failurePresenter);
diff --git a/src/test/java/use_case/save_event/SaveEventInteractorTest.java b/src/test/java/use_case/save_event/SaveEventInteractorTest.java
new file mode 100644
index 00000000..7cc3105d
--- /dev/null
+++ b/src/test/java/use_case/save_event/SaveEventInteractorTest.java
@@ -0,0 +1,344 @@
+//Assisted by AI
+package use_case.save_event;
+
+import data_access.FileSavedEventsDataAccessObject;
+import entity.Event;
+import entity.EventCategory;
+import entity.Location;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import use_case.login.LoginUserDataAccessInterface;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Test class for SaveEventInteractor.
+ * Tests the save event use case functionality including:
+ * - Successful event saving
+ * - Duplicate event detection
+ * - Null event handling
+ * - Event removal
+ * - Checking if event is saved
+ */
+class SaveEventInteractorTest {
+
+ private SaveEventInteractor interactor;
+ private TestSaveEventPresenter testPresenter;
+ private TestSavedEventsDAO testDAO;
+ private TestUserDataAccess testUserDataAccess;
+ private Event testEvent;
+
+ @BeforeEach
+ void setUp() {
+ // Create test event
+ Location location = new Location("Test Venue, Toronto", 43.6532, -79.3832);
+ testEvent = new Event(
+ "test-123",
+ "Test Concert",
+ "A great test concert",
+ "Test Venue, Toronto",
+ EventCategory.MUSIC,
+ location,
+ LocalDateTime.of(2025, 12, 15, 19, 0),
+ "http://example.com/image.jpg"
+ );
+
+ testPresenter = new TestSaveEventPresenter();
+ testDAO = new TestSavedEventsDAO();
+ testUserDataAccess = new TestUserDataAccess();
+
+ interactor = new SaveEventInteractor(testPresenter, testDAO, testUserDataAccess);
+ }
+
+ @Test
+ void testExecute_successfulSave() {
+ testUserDataAccess.setCurrentUsername("testuser");
+ SaveEventInputData inputData = new SaveEventInputData(testEvent);
+
+ interactor.execute(inputData);
+
+ assertTrue(testPresenter.isSuccessCalled(), "Success view should be called");
+ assertFalse(testPresenter.isFailureCalled(), "Failure view should not be called");
+ assertEquals(testEvent, testPresenter.getOutputData().getEvent(), "Output should contain the saved event");
+ assertEquals(1, testDAO.getSavedEventCount("testuser"), "Event should be saved once");
+ assertTrue(testDAO.isEventSaved("testuser", testEvent.getId()), "Event should be marked as saved");
+ }
+
+ @Test
+ void testExecute_nullEvent() {
+ // Arrange
+ testUserDataAccess.setCurrentUsername("testuser");
+ SaveEventInputData inputData = new SaveEventInputData(null);
+
+ // Act
+ interactor.execute(inputData);
+
+ // Assert
+ assertTrue(testPresenter.isFailureCalled(), "Failure view should be called");
+ assertFalse(testPresenter.isSuccessCalled(), "Success view should not be called");
+ assertEquals("No Event Found", testPresenter.getErrorMessage(), "Error message should indicate no event");
+ assertEquals(0, testDAO.getSavedEventCount("testuser"), "No events should be saved");
+ }
+
+ @Test
+ void testExecute_duplicateEvent() {
+ testUserDataAccess.setCurrentUsername("testuser");
+ SaveEventInputData inputData = new SaveEventInputData(testEvent);
+
+ interactor.execute(inputData);
+ testPresenter.reset();
+
+ interactor.execute(inputData);
+
+ assertTrue(testPresenter.isFailureCalled(), "Failure view should be called for duplicate");
+ assertFalse(testPresenter.isSuccessCalled(), "Success view should not be called for duplicate");
+ assertEquals("Event already saved", testPresenter.getErrorMessage(),
+ "Error message should indicate duplicate");
+ assertEquals(1, testDAO.getSavedEventCount("testuser"),
+ "Event should still only be saved once");
+ }
+
+ @Test
+ void testGetSavedEvents() {
+ testUserDataAccess.setCurrentUsername("testuser");
+ SaveEventInputData inputData = new SaveEventInputData(testEvent);
+ interactor.execute(inputData);
+
+ List savedEvents = interactor.getSavedEvents();
+
+ assertNotNull(savedEvents, "Saved events list should not be null");
+ assertEquals(1, savedEvents.size(), "Should have one saved event");
+ assertEquals(testEvent.getId(), savedEvents.get(0).getId(), "Saved event should match test event");
+ }
+
+ @Test
+ void testGetSavedEvents_noUser() {
+ testUserDataAccess.setCurrentUsername(null);
+
+ List savedEvents = interactor.getSavedEvents();
+
+ assertNotNull(savedEvents, "Saved events list should not be null");
+ assertEquals(0, savedEvents.size(), "Should have no saved events when no user");
+ }
+
+ @Test
+ void testUnsaveEvent() {
+ testUserDataAccess.setCurrentUsername("testuser");
+ SaveEventInputData inputData = new SaveEventInputData(testEvent);
+ interactor.execute(inputData);
+
+ interactor.unsaveEvent(testEvent);
+
+ assertEquals(0, testDAO.getSavedEventCount("testuser"), "Event should be removed");
+ assertFalse(testDAO.isEventSaved("testuser", testEvent.getId()), "Event should not be marked as saved");
+ }
+
+ @Test
+ void testUnsaveEvent_noUser() {
+ testUserDataAccess.setCurrentUsername("testuser");
+ SaveEventInputData inputData = new SaveEventInputData(testEvent);
+ interactor.execute(inputData);
+
+ testUserDataAccess.setCurrentUsername(null);
+
+ interactor.unsaveEvent(testEvent);
+
+ assertEquals(1, testDAO.getSavedEventCount("testuser"), "Event should not be removed without user");
+ }
+
+ @Test
+ void testIsEventSaved() {
+ testUserDataAccess.setCurrentUsername("testuser");
+ SaveEventInputData inputData = new SaveEventInputData(testEvent);
+ interactor.execute(inputData);
+
+ assertTrue(interactor.isEventSaved(testEvent.getId()), "Event should be marked as saved");
+ assertFalse(interactor.isEventSaved("nonexistent-id"), "Non-existent event should not be marked as saved");
+ }
+
+ @Test
+ void testIsEventSaved_nullEventId() {
+ testUserDataAccess.setCurrentUsername("testuser");
+
+ assertFalse(interactor.isEventSaved(null), "Null event ID should return false");
+ }
+
+ @Test
+ void testIsEventSaved_noUser() {
+ testUserDataAccess.setCurrentUsername(null);
+
+ assertFalse(interactor.isEventSaved(testEvent.getId()), "Should return false when no user");
+ }
+
+ @Test
+ void testSwitchToDashboardView() {
+ interactor.switchToDashboardView();
+
+ assertTrue(testPresenter.isSwitchToDashboardCalled(), "Switch to dashboard should be called");
+ }
+
+ @Test
+ void testRemoveEvent() {
+ testUserDataAccess.setCurrentUsername("testuser");
+ SaveEventInputData inputData = new SaveEventInputData(testEvent);
+ interactor.execute(inputData);
+
+ interactor.removeEvent(testEvent);
+
+ assertEquals(0, testDAO.getSavedEventCount("testuser"), "Event should be removed");
+ assertFalse(testDAO.isEventSaved("testuser", testEvent.getId()), "Event should not be marked as saved");
+ }
+
+ @Test
+ void testRemoveEvent_noUser() {
+ testUserDataAccess.setCurrentUsername("testuser");
+ SaveEventInputData inputData = new SaveEventInputData(testEvent);
+ interactor.execute(inputData);
+
+ testUserDataAccess.setCurrentUsername(null);
+
+ interactor.removeEvent(testEvent);
+
+ assertEquals(1, testDAO.getSavedEventCount("testuser"), "Event should not be removed without user");
+ }
+
+ @Test
+ void testIsEventSaved_nullUsername() {
+ testUserDataAccess.setCurrentUsername(null);
+
+ assertFalse(interactor.isEventSaved("some-event-id"), "Should return false when username is null");
+ }
+
+
+ /**
+ * Test implementation of SaveEventOutputBoundary.
+ */
+ private static class TestSaveEventPresenter implements SaveEventOutputBoundary {
+ private boolean successCalled = false;
+ private boolean failureCalled = false;
+ private boolean switchToDashboardCalled = false;
+ private SaveEventOutputData outputData;
+ private String errorMessage;
+
+ @Override
+ public void prepareSuccessView(SaveEventOutputData outputData) {
+ this.successCalled = true;
+ this.outputData = outputData;
+ }
+
+ @Override
+ public void prepareFailureView(String errorMessage) {
+ this.failureCalled = true;
+ this.errorMessage = errorMessage;
+ }
+
+ @Override
+ public void switchToDashboardView() {
+ this.switchToDashboardCalled = true;
+ }
+
+ public boolean isSuccessCalled() {
+ return successCalled;
+ }
+
+ public boolean isFailureCalled() {
+ return failureCalled;
+ }
+
+ public boolean isSwitchToDashboardCalled() {
+ return switchToDashboardCalled;
+ }
+
+ public SaveEventOutputData getOutputData() {
+ return outputData;
+ }
+
+ public String getErrorMessage() {
+ return errorMessage;
+ }
+
+ public void reset() {
+ successCalled = false;
+ failureCalled = false;
+ switchToDashboardCalled = false;
+ outputData = null;
+ errorMessage = null;
+ }
+ }
+
+ /**
+ * Test implementation of FileSavedEventsDataAccessObject.
+ */
+ private static class TestSavedEventsDAO extends FileSavedEventsDataAccessObject {
+ private final List savedEvents = new ArrayList<>();
+ private String currentUser = null;
+
+ @Override
+ public void saveEvent(String username, Event event) {
+ currentUser = username;
+ if (!isEventSaved(username, event.getId())) {
+ savedEvents.add(event);
+ }
+ }
+
+ @Override
+ public List getSavedEvents(String username) {
+ if (username == null) {
+ return new ArrayList<>();
+ }
+ return new ArrayList<>(savedEvents);
+ }
+
+ @Override
+ public void unsaveEvent(String username, Event event) {
+ savedEvents.removeIf(e -> e.getId().equals(event.getId()));
+ }
+
+ @Override
+ public boolean isEventSaved(String username, String eventId) {
+ if (username == null || eventId == null) {
+ return false;
+ }
+ return savedEvents.stream().anyMatch(e -> e.getId().equals(eventId));
+ }
+
+ public int getSavedEventCount(String username) {
+ return getSavedEvents(username).size();
+ }
+ }
+
+ /**
+ * Test implementation of LoginUserDataAccessInterface.
+ */
+ private static class TestUserDataAccess implements LoginUserDataAccessInterface {
+ private String currentUsername;
+
+ @Override
+ public boolean existsByName(String username) {
+ return true;
+ }
+
+ @Override
+ public void save(entity.User user) {
+ }
+
+ @Override
+ public entity.User get(String username) {
+ return null;
+ }
+
+ @Override
+ public void setCurrentUsername(String name) {
+ this.currentUsername = name;
+ }
+
+ @Override
+ public String getCurrentUsername() {
+ return currentUsername;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/use_case/search_event/SearchEventByNameInteractorTest.java b/src/test/java/use_case/search_event/SearchEventByNameInteractorTest.java
new file mode 100644
index 00000000..55020b61
--- /dev/null
+++ b/src/test/java/use_case/search_event/SearchEventByNameInteractorTest.java
@@ -0,0 +1,4 @@
+package use_case.search_event;
+
+public class SearchEventByNameInteractorTest {
+}