Nákupy v Thassosu

Nákupy na Thassosu – řecký ostrovní shopping

Thassos nepatří mezi typické nákupní destinace, jako jsou Atény nebo Soluň, ale přesto nabízí překvapivě pestré možnosti, jak si dopřát radost z nakupování. Na tomto kouzelném ostrově najdete vše od tradičních řeckých produktů až po luxusní zboží, a to v prostředí, které si zachovává autentický řecký charakter. Nákupy na Thassosu se od těch v přeplněných obchodních centrech evropských metropolí výrazně liší – probíhají v poklidném tempu, často za doprovodu přátelského rozhovoru s místními prodejci.

Největší koncentraci obchodů najdete pochopitelně v hlavním městě Limenas (Thassos Town) a v populárních letoviscích jako Limenaria, Potos nebo Skala Potamias. Turisticky oblíbená letoviska nabízejí především suvenýry, plážové vybavení a řemeslné výrobky. V méně navštěvovaných oblastech pak můžete objevit autentické rodinné obchůdky s lokálními produkty, které nenesou přirážku pro turisty.

Co byste si z Thassosu určitě měli přivézt? Ostrov je proslulý svým vynikajícím olivovým olejem, medem, ouzo, vínem a keramikou. Pokud hledáte autentický suvenýr, nemůžete minout ručně vyráběné šperky z olivového dřeva nebo přírodní kosmetiku s extrakty z místních bylinek a olivového oleje. Thassos je také známý svým bílým mramorem, který se zde těží už od starověku.

Nejoblíbenější nákupní lokality

Ostrov Thassos nabízí rozmanité nákupní příležitosti, od rušných turistických center až po klidné vesničky s tradičními obchůdky. Každá oblast má svůj specifický charakter a sortiment. Pojďme se podívat na nejoblíbenější místa, kde si můžete užít nákupy během vaší dovolené.

Limenas (Thassos Town)

Hlavní město ostrova nabízí nejširší výběr obchodů a je ideálním místem pro ty, kteří hledají rozmanitost. Centrum města je protkáno dlážděnými uličkami, kde najdete butiky, obchody se suvenýry i specializované prodejny. Hlavní nákupní zóna se rozprostírá kolem přístavu a na hlavní třídě.

V Limenas najdete:

• Dimitriadis Jewellery – rodinný podnik s tradicí od roku 1977, nabízející jedinečné šperky inspirované řeckou historií
• To Perivoli – obchod s lokálními potravinami, kde koupíte kvalitní olivový olej, med, bylinky a domácí zavařeniny
• Thassos Art – galerie s díly místních umělců, keramika a originální suvenýry
• Několik supermarketů včetně větších řetězců jako Masoutis a Lidl

Náš tajný tip: Navštivte malý obchůdek Melissokomika Thasou v boční uličce nedaleko přístavu, kde prodávají více než 15 druhů místního medu včetně vzácného tymiánového a piniového. Majitel vám rád nabídne ochutnávku a vysvětlí rozdíly mezi jednotlivými druhy.

Pro dopravu do Limenas můžete využít místní autobusovou dopravu (KTEL), která spojuje hlavní město s většinou letovisek na ostrově. Pokud máte pronajatý vůz, ve městě najdete několik parkovišť, i když v hlavní sezóně mohou být často plná.

Limenaria

Druhé největší město ostrova a oblíbené letovisko na jihozápadním pobřeží nabízí příjemné nákupní možnosti v poklidnější atmosféře než v hlavním městě. Hlavní obchodní ulice lemuje pobřeží a nabízí krásné výhledy na moře během vašich nákupů.

V Limenarii stojí za návštěvu:

• Olive Wood House – specializovaný obchod s výrobky z olivového dřeva od užitkových předmětů po umělecká díla
• Thassos Marble Products – obchod nabízející dekorativní předměty z proslulého thassoského mramoru
• Traditional Products of Thassos – rodinný podnik s lokálními potravinami včetně domácích likérů a marmelád

Do Limenarie se snadno dostanete autobusem z Limenas, cesta trvá přibližně 45 minut. Pokud cestujete autem, ve městě najdete dostatek parkovacích míst, i když v hlavní sezóně mohou být placená.

Potos

Toto živé letovisko na jižním pobřeží ostrova je známé svým nočním životem, ale nabízí také skvělé nákupní možnosti. Hlavní nákupní zóna se nachází podél pobřežní promenády a v okolních uličkách. V Potosu najdete více obchodů zaměřených na turisty, ale i několik kvalitních míst s místními produkty.

Zajímavé obchody v Potosu:

• Honey Farm – obchod s včelími produkty, kde můžete ochutnat a zakoupit různé druhy místního medu
• Thassos Olive Oil – specializovaný obchod s olivovým olejem z místních lisoven
• Několik butikCertainly! Here's a well-structured README for a course management system using Java, Spring Boot, PostgreSQL, and React: --- # Course Management System ## Project Overview This Course Management System is a comprehensive application designed to manage courses, students, instructors, and academic resources. Built with a modern tech stack, it provides robust functionality for educational institutions. ### Features - User authentication and role-based access control (Admin, Instructor, Student) - Course creation and management - Student enrollment and grade tracking - Assignment submission and evaluation - Timetable management - Academic resource sharing ## Technology Stack ### Backend - **Language**: Java 17 - **Framework**: Spring Boot 3.x - **Database**: PostgreSQL 14 - **API Documentation**: Swagger/OpenAPI - **Authentication**: JWT - **Build Tool**: Maven ### Frontend - **Library**: React 18.x - **State Management**: Redux - **UI Framework**: Material-UI - **HTTP Client**: Axios ## Project Structure ``` course-management-system/ ├── backend/ # Spring Boot application │ ├── src/ │ │ ├── main/ │ │ │ ├── java/com/coursemanagement/ │ │ │ │ ├── config/ │ │ │ │ ├── controller/ │ │ │ │ ├── dto/ │ │ │ │ ├── exception/ │ │ │ │ ├── model/ │ │ │ │ ├── repository/ │ │ │ │ ├── security/ │ │ │ │ ├── service/ │ │ │ │ └── CourseManagementApplication.java │ │ │ └── resources/ │ │ │ ├── application.properties │ │ │ └── db/migration/ │ │ └── test/ │ └── pom.xml ├── frontend/ # React application │ ├── public/ │ ├── src/ │ │ ├── components/ │ │ ├── pages/ │ │ ├── redux/ │ │ ├── services/ │ │ ├── utils/ │ │ ├── App.js │ │ └── index.js │ ├── package.json │ └── README.md ├── docker-compose.yml # Docker configuration └── README.md # Project documentation ``` ## Database Schema The database includes the following main entities: - **Users**: Stores user information with role-based attributes - **Courses**: Course details, prerequisites, and enrollment limits - **Enrollments**: Tracks student enrollments in courses - **Assignments**: Course assignments and submission details - **Submissions**: Student submissions for assignments - **Grades**: Student grades for assignments and courses - **Resources**: Educational materials linked to courses ## API Endpoints ### Authentication - `POST /api/auth/login`: User login - `POST /api/auth/register`: User registration ### Courses - `GET /api/courses`: Get all courses - `GET /api/courses/{id}`: Get course by ID - `POST /api/courses`: Create new course - `PUT /api/courses/{id}`: Update course - `DELETE /api/courses/{id}`: Delete course ### Enrollments - `GET /api/enrollments`: Get all enrollments - `POST /api/enrollments`: Enroll student in course - `DELETE /api/enrollments/{id}`: Unenroll student ### Assignments - `GET /api/courses/{courseId}/assignments`: Get assignments for course - `POST /api/courses/{courseId}/assignments`: Create assignment - `PUT /api/assignments/{id}`: Update assignment - `DELETE /api/assignments/{id}`: Delete assignment ### Submissions - `POST /api/assignments/{id}/submissions`: Submit assignment - `GET /api/assignments/{id}/submissions`: Get submissions for assignment - `GET /api/students/{id}/submissions`: Get student submissions ### Grades - `POST /api/submissions/{id}/grade`: Grade submission - `GET /api/students/{id}/grades`: Get student grades - `GET /api/courses/{id}/grades`: Get course grades ## Setup and Installation ### Prerequisites - Java 17+ - Node.js 16+ - PostgreSQL 14+ - Docker and Docker Compose (optional) ### Backend Setup 1. Clone the repository ```bash git clone https://github.com/yourusername/course-management-system.git cd course-management-system ``` 2. Configure PostgreSQL database ``` # In application.properties spring.datasource.url=jdbc:postgresql://localhost:5432/course_management spring.datasource.username=postgres spring.datasource.password=yourpassword ``` 3. Build and run the Spring Boot application ```bash cd backend mvn clean install mvn spring-boot:run ``` The backend will be available at `http://localhost:8080` ### Frontend Setup 1. Install dependencies ```bash cd frontend npm install ``` 2. Configure API endpoint ``` # In .env file REACT_APP_API_URL=http://localhost:8080/api ``` 3. Start the React application ```bash npm start ``` The frontend will be available at `http://localhost:3000` ### Using Docker ```bash docker-compose up -d ``` ## Testing ### Backend Testing ```bash cd backend mvn test ``` ### Frontend Testing ```bash cd frontend npm test ``` ## Documentation - API Documentation: Available at `http://localhost:8080/swagger-ui.html` when the backend is running - Frontend Component Documentation: Available at `http://localhost:6006` after running `npm run storybook` ## Security Features - JWT Authentication - Role-based access control - Password encryption - Input validation - CSRF protection - Rate limiting ## License This project is licensed under the MIT License - see the LICENSE file for details. ## Contributors - [Your Name](https://github.com/yourusername) --- Feel free to customize this README to match your specific implementation details and preferences. This template provides a comprehensive structure that covers all major aspects of a modern web application project. End File# aakriti0fnu/CourseManagement # api/src/main/java/edu/northeastern/course_management/controller/LessonController.java package edu.northeastern.course_management.controller; import java.util.List; import java.util.stream.Collectors; import edu.northeastern.course_management.dto.LessonDTO; import edu.northeastern.course_management.dto.ModuleDTO; import edu.northeastern.course_management.model.Lesson; import edu.northeastern.course_management.model.Module; import edu.northeastern.course_management.service.LessonService; import edu.northeastern.course_management.service.ModuleService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; @RestController @RequestMapping("/api/lessons") @CrossOrigin(origins = "*") public class LessonController { private static final Logger logger = LoggerFactory.getLogger(LessonController.class); @Autowired private LessonService lessonService; @Autowired private ModuleService moduleService; // Get all lessons for a specific module @GetMapping("/module/{moduleId}") public ResponseEntity<List> getLessonsByModuleId(@PathVariable Long moduleId) { logger.info("Fetching all lessons for module with ID: {}", moduleId); List lessons = lessonService.getLessonsByModuleId(moduleId); List lessonDTOs = lessons.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(lessonDTOs); } // Get a lesson by ID @GetMapping("/{id}") public ResponseEntity getLessonById(@PathVariable Long id) { logger.info("Fetching lesson with ID: {}", id); Lesson lesson = lessonService.getLessonById(id); if (lesson != null) { return ResponseEntity.ok(convertToDTO(lesson)); } else { return ResponseEntity.notFound().build(); } } // Create a new lesson @PostMapping public ResponseEntity createLesson(@RequestBody LessonDTO lessonDTO) { logger.info("Creating new lesson: {}", lessonDTO); Lesson lesson = convertToEntity(lessonDTO); Lesson savedLesson = lessonService.createLesson(lesson); return ResponseEntity.ok(convertToDTO(savedLesson)); } // Update a lesson @PutMapping("/{id}") public ResponseEntity updateLesson(@PathVariable Long id, @RequestBody LessonDTO lessonDTO) { logger.info("Updating lesson with ID: {}", id); Lesson existingLesson = lessonService.getLessonById(id); if (existingLesson == null) { return ResponseEntity.notFound().build(); } Lesson lesson = convertToEntity(lessonDTO); lesson.setId(id); Lesson updatedLesson = lessonService.updateLesson(lesson); return ResponseEntity.ok(convertToDTO(updatedLesson)); } // Delete a lesson @DeleteMapping("/{id}") public ResponseEntity deleteLesson(@PathVariable Long id) { logger.info("Deleting lesson with ID: {}", id); Lesson existingLesson = lessonService.getLessonById(id); if (existingLesson == null) { return ResponseEntity.notFound().build(); } lessonService.deleteLesson(id); return ResponseEntity.noContent().build(); } // Helper method to convert entity to DTO private LessonDTO convertToDTO(Lesson lesson) { LessonDTO dto = new LessonDTO(); dto.setId(lesson.getId()); dto.setTitle(lesson.getTitle()); dto.setDescription(lesson.getDescription()); dto.setContent(lesson.getContent()); dto.setOrderIndex(lesson.getOrderIndex()); dto.setModuleId(lesson.getModule().getId()); return dto; } // Helper method to convert DTO to entity private Lesson convertToEntity(LessonDTO lessonDTO) { Lesson lesson = new Lesson(); lesson.setId(lessonDTO.getId()); lesson.setTitle(lessonDTO.getTitle()); lesson.setDescription(lessonDTO.getDescription()); lesson.setContent(lessonDTO.getContent()); lesson.setOrderIndex(lessonDTO.getOrderIndex()); // Set module if moduleId is provided if (lessonDTO.getModuleId() != null) { Module module = moduleService.getModuleById(lessonDTO.getModuleId()); lesson.setModule(module); } return lesson; } } End File# aakriti0fnu/CourseManagement # api/src/main/java/edu/northeastern/course_management/controller/UserController.java package edu.northeastern.course_management.controller; import edu.northeastern.course_management.dto.UserDTO; import edu.northeastern.course_management.model.User; import edu.northeastern.course_management.service.UserService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.util.List; import java.util.stream.Collectors; @RestController @RequestMapping("/api/users") @CrossOrigin(origins = "*") public class UserController { private static final Logger logger = LoggerFactory.getLogger(UserController.class); @Autowired private UserService userService; // Get all users @GetMapping public ResponseEntity<List> getAllUsers() { logger.info("Fetching all users"); List users = userService.getAllUsers(); List userDTOs = users.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(userDTOs); } // Get user by ID @GetMapping("/{id}") public ResponseEntity getUserById(@PathVariable Long id) { logger.info("Fetching user with ID: {}", id); User user = userService.getUserById(id); if (user != null) { return ResponseEntity.ok(convertToDTO(user)); } else { return ResponseEntity.notFound().build(); } } // Create a new user @PostMapping public ResponseEntity createUser(@RequestBody UserDTO userDTO) { logger.info("Creating new user: {}", userDTO); try { User user = convertToEntity(userDTO); User savedUser = userService.createUser(user); return new ResponseEntity<>(convertToDTO(savedUser), HttpStatus.CREATED); } catch (Exception e) { logger.error("Error creating user", e); return ResponseEntity.badRequest().build(); } } // Update user @PutMapping("/{id}") public ResponseEntity updateUser(@PathVariable Long id, @RequestBody UserDTO userDTO) { logger.info("Updating user with ID: {}", id); User existingUser = userService.getUserById(id); if (existingUser == null) { return ResponseEntity.notFound().build(); } User user = convertToEntity(userDTO); user.setId(id); User updatedUser = userService.updateUser(user); return ResponseEntity.ok(convertToDTO(updatedUser)); } // Delete user @DeleteMapping("/{id}") public ResponseEntity deleteUser(@PathVariable Long id) { logger.info("Deleting user with ID: {}", id); User existingUser = userService.getUserById(id); if (existingUser == null) { return ResponseEntity.notFound().build(); } userService.deleteUser(id); return ResponseEntity.noContent().build(); } // Get user by username @GetMapping("/username/{username}") public ResponseEntity getUserByUsername(@PathVariable String username) { logger.info("Fetching user with username: {}", username); User user = userService.getUserByUsername(username); if (user != null) { return ResponseEntity.ok(convertToDTO(user)); } else { return ResponseEntity.notFound().build(); } } // Helper method to convert entity to DTO private UserDTO convertToDTO(User user) { UserDTO dto = new UserDTO(); dto.setId(user.getId()); dto.setUsername(user.getUsername()); // Don't include password in DTO for security dto.setEmail(user.getEmail()); dto.setFirstName(user.getFirstName()); dto.setLastName(user.getLastName()); dto.setRole(user.getRole()); dto.setProfilePicture(user.getProfilePicture()); dto.setActive(user.isActive()); dto.setCreatedAt(user.getCreatedAt()); dto.setUpdatedAt(user.getUpdatedAt()); return dto; } // Helper method to convert DTO to entity private User convertToEntity(UserDTO userDTO) { User user = new User(); user.setId(userDTO.getId()); user.setUsername(userDTO.getUsername()); // Only set password if it's provided in the DTO (for updates) if (userDTO.getPassword() != null && !userDTO.getPassword().isEmpty()) { user.setPassword(userDTO.getPassword()); } user.setEmail(userDTO.getEmail()); user.setFirstName(userDTO.getFirstName()); user.setLastName(userDTO.getLastName()); user.setRole(userDTO.getRole()); user.setProfilePicture(userDTO.getProfilePicture()); user.setActive(userDTO.isActive()); return user; } } End Filepackage edu.northeastern.course_management.controller; import edu.northeastern.course_management.dto.CourseDTO; import edu.northeastern.course_management.model.Course; import edu.northeastern.course_management.service.CourseService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.time.LocalDateTime; import java.util.List; import java.util.stream.Collectors; @RestController @RequestMapping("/api/courses") @CrossOrigin(origins = "*") public class CourseController { private static final Logger logger = LoggerFactory.getLogger(CourseController.class); @Autowired private CourseService courseService; // Get all courses @GetMapping public ResponseEntity<List> getAllCourses() { logger.info("Fetching all courses"); List courses = courseService.getAllCourses(); List courseDTOs = courses.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(courseDTOs); } // Get course by ID @GetMapping("/{id}") public ResponseEntity getCourseById(@PathVariable Long id) { logger.info("Fetching course with ID: {}", id); Course course = courseService.getCourseById(id); if (course != null) { return ResponseEntity.ok(convertToDTO(course)); } else { return ResponseEntity.notFound().build(); } } // Create a new course @PostMapping public ResponseEntity createCourse(@RequestBody CourseDTO courseDTO) { logger.info("Creating new course: {}", courseDTO); Course course = convertToEntity(courseDTO); course.setCreatedAt(LocalDateTime.now()); Course savedCourse = courseService.createCourse(course); return ResponseEntity.ok(convertToDTO(savedCourse)); } // Update a course @PutMapping("/{id}") public ResponseEntity updateCourse(@PathVariable Long id, @RequestBody CourseDTO courseDTO) { logger.info("Updating course with ID: {}", id); Course existingCourse = courseService.getCourseById(id); if (existingCourse == null) { return ResponseEntity.notFound().build(); } Course course = convertToEntity(courseDTO); course.setId(id); course.setCreatedAt(existingCourse.getCreatedAt()); course.setUpdatedAt(LocalDateTime.now()); Course updatedCourse = courseService.updateCourse(course); return ResponseEntity.ok(convertToDTO(updatedCourse)); } // Delete a course @DeleteMapping("/{id}") public ResponseEntity deleteCourse(@PathVariable Long id) { logger.info("Deleting course with ID: {}", id); Course existingCourse = courseService.getCourseById(id); if (existingCourse == null) { return ResponseEntity.notFound().build(); } courseService.deleteCourse(id); return ResponseEntity.noContent().build(); } // Get courses by instructor ID @GetMapping("/instructor/{instructorId}") public ResponseEntity<List> getCoursesByInstructorId(@PathVariable Long instructorId) { logger.info("Fetching courses for instructor with ID: {}", instructorId); List courses = courseService.getCoursesByInstructorId(instructorId); List courseDTOs = courses.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(courseDTOs); } // Get courses by student ID (enrolled courses) @GetMapping("/student/{studentId}") public ResponseEntity<List> getCoursesByStudentId(@PathVariable Long studentId) { logger.info("Fetching courses for student with ID: {}", studentId); List courses = courseService.getCoursesByStudentId(studentId); List courseDTOs = courses.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(courseDTOs); } // Helper method to convert entity to DTO private CourseDTO convertToDTO(Course course) { CourseDTO dto = new CourseDTO(); dto.setId(course.getId()); dto.setTitle(course.getTitle()); dto.setCode(course.getCode()); dto.setDescription(course.getDescription()); dto.setStatus(course.getStatus()); dto.setInstructorId(course.getInstructorId()); dto.setStartDate(course.getStartDate()); dto.setEndDate(course.getEndDate()); dto.setEnrollmentCapacity(course.getEnrollmentCapacity()); dto.setCoverImage(course.getCoverImage()); dto.setCreatedAt(course.getCreatedAt()); dto.setUpdatedAt(course.getUpdatedAt()); return dto; } // Helper method to convert DTO to entity private Course convertToEntity(CourseDTO courseDTO) { Course course = new Course(); course.setId(courseDTO.getId()); course.setTitle(courseDTO.getTitle()); course.setCode(courseDTO.getCode()); course.setDescription(courseDTO.getDescription()); course.setStatus(courseDTO.getStatus()); course.setInstructorId(courseDTO.getInstructorId()); course.setStartDate(courseDTO.getStartDate()); course.setEndDate(courseDTO.getEndDate()); course.setEnrollmentCapacity(courseDTO.getEnrollmentCapacity()); course.setCoverImage(courseDTO.getCoverImage()); return course; } } End Filepackage edu.northeastern.course_management.controller; import edu.northeastern.course_management.dto.ModuleDTO; import edu.northeastern.course_management.model.Module; import edu.northeastern.course_management.service.CourseService; import edu.northeastern.course_management.service.ModuleService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.time.LocalDateTime; import java.util.List; import java.util.stream.Collectors; @RestController @RequestMapping("/api/modules") @CrossOrigin(origins = "*") public class ModuleController { private static final Logger logger = LoggerFactory.getLogger(ModuleController.class); @Autowired private ModuleService moduleService; @Autowired private CourseService courseService; // Get all modules @GetMapping public ResponseEntity<List> getAllModules() { logger.info("Fetching all modules"); List modules = moduleService.getAllModules(); List moduleDTOs = modules.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(moduleDTOs); } // Get module by ID @GetMapping("/{id}") public ResponseEntity getModuleById(@PathVariable Long id) { logger.info("Fetching module with ID: {}", id); Module module = moduleService.getModuleById(id); if (module != null) { return ResponseEntity.ok(convertToDTO(module)); } else { return ResponseEntity.notFound().build(); } } // Get modules by course ID @GetMapping("/course/{courseId}") public ResponseEntity<List> getModulesByCourseId(@PathVariable Long courseId) { logger.info("Fetching modules for course with ID: {}", courseId); List modules = moduleService.getModulesByCourseId(courseId); List moduleDTOs = modules.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(moduleDTOs); } // Create a new module @PostMapping public ResponseEntity createModule(@RequestBody ModuleDTO moduleDTO) { logger.info("Creating new module: {}", moduleDTO); Module module = convertToEntity(moduleDTO); module.setCreatedAt(LocalDateTime.now()); Module savedModule = moduleService.createModule(module); return ResponseEntity.ok(convertToDTO(savedModule)); } // Update a module @PutMapping("/{id}") public ResponseEntity updateModule(@PathVariable Long id, @RequestBody ModuleDTO moduleDTO) { logger.info("Updating module with ID: {}", id); Module existingModule = moduleService.getModuleById(id); if (existingModule == null) { return ResponseEntity.notFound().build(); } Module module = convertToEntity(moduleDTO); module.setId(id); module.setCreatedAt(existingModule.getCreatedAt()); module.setUpdatedAt(LocalDateTime.now()); Module updatedModule = moduleService.updateModule(module); return ResponseEntity.ok(convertToDTO(updatedModule)); } // Delete a module @DeleteMapping("/{id}") public ResponseEntity deleteModule(@PathVariable Long id) { logger.info("Deleting module with ID: {}", id); Module existingModule = moduleService.getModuleById(id); if (existingModule == null) { return ResponseEntity.notFound().build(); } moduleService.deleteModule(id); return ResponseEntity.noContent().build(); } // Helper method to convert entity to DTO private ModuleDTO convertToDTO(Module module) { ModuleDTO dto = new ModuleDTO(); dto.setId(module.getId()); dto.setTitle(module.getTitle()); dto.setDescription(module.getDescription()); dto.setOrderIndex(module.getOrderIndex()); dto.setCourseId(module.getCourse().getId()); dto.setStartDate(module.getStartDate()); dto.setEndDate(module.getEndDate()); dto.setCreatedAt(module.getCreatedAt()); dto.setUpdatedAt(module.getUpdatedAt()); return dto; } // Helper method to convert DTO to entity private Module convertToEntity(ModuleDTO moduleDTO) { Module module = new Module(); module.setId(moduleDTO.getId()); module.setTitle(moduleDTO.getTitle()); module.setDescription(moduleDTO.getDescription()); module.setOrderIndex(moduleDTO.getOrderIndex()); module.setCourse(courseService.getCourseById(moduleDTO.getCourseId())); module.setStartDate(moduleDTO.getStartDate()); module.setEndDate(moduleDTO.getEndDate()); return module; } } End Filepackage edu.northeastern.course_management.controller; import edu.northeastern.course_management.dto.ResourceDTO; import edu.northeastern.course_management.model.Resource; import edu.northeastern.course_management.service.CourseService; import edu.northeastern.course_management.service.ResourceService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.time.LocalDateTime; import java.util.List; import java.util.stream.Collectors; @RestController @RequestMapping("/api/resources") @CrossOrigin(origins = "*") public class ResourceController { private static final Logger logger = LoggerFactory.getLogger(ResourceController.class); @Autowired private ResourceService resourceService; @Autowired private CourseService courseService; // Get all resources @GetMapping public ResponseEntity<List> getAllResources() { logger.info("Fetching all resources"); List resources = resourceService.getAllResources(); List resourceDTOs = resources.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(resourceDTOs); } // Get resource by ID @GetMapping("/{id}") public ResponseEntity getResourceById(@PathVariable Long id) { logger.info("Fetching resource with ID: {}", id); Resource resource = resourceService.getResourceById(id); if (resource != null) { return ResponseEntity.ok(convertToDTO(resource)); } else { return ResponseEntity.notFound().build(); } } // Get resources by course ID @GetMapping("/course/{courseId}") public ResponseEntity<List> getResourcesByCourseId(@PathVariable Long courseId) { logger.info("Fetching resources for course with ID: {}", courseId); List resources = resourceService.getResourcesByCourseId(courseId); List resourceDTOs = resources.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(resourceDTOs); } // Create a new resource @PostMapping public ResponseEntity createResource(@RequestBody ResourceDTO resourceDTO) { logger.info("Creating new resource: {}", resourceDTO); Resource resource = convertToEntity(resourceDTO); resource.setCreatedAt(LocalDateTime.now()); Resource savedResource = resourceService.createResource(resource); return ResponseEntity.ok(convertToDTO(savedResource)); } // Update a resource @PutMapping("/{id}") public ResponseEntity updateResource(@PathVariable Long id, @RequestBody ResourceDTO resourceDTO) { logger.info("Updating resource with ID: {}", id); Resource existingResource = resourceService.getResourceById(id); if (existingResource == null) { return ResponseEntity.notFound().build(); } Resource resource = convertToEntity(resourceDTO); resource.setId(id); resource.setCreatedAt(existingResource.getCreatedAt()); resource.setUpdatedAt(LocalDateTime.now()); Resource updatedResource = resourceService.updateResource(resource); return ResponseEntity.ok(convertToDTO(updatedResource)); } // Delete a resource @DeleteMapping("/{id}") public ResponseEntity deleteResource(@PathVariable Long id) { logger.info("Deleting resource with ID: {}", id); Resource existingResource = resourceService.getResourceById(id); if (existingResource == null) { return ResponseEntity.notFound().build(); } resourceService.deleteResource(id); return ResponseEntity.noContent().build(); } // Helper method to convert entity to DTO private ResourceDTO convertToDTO(Resource resource) { ResourceDTO dto = new ResourceDTO(); dto.setId(resource.getId()); dto.setTitle(resource.getTitle()); dto.setDescription(resource.getDescription()); dto.setType(resource.getType()); dto.setUrl(resource.getUrl()); dto.setFilePath(resource.getFilePath()); if (resource.getCourse() != null) { dto.setCourseId(resource.getCourse().getId()); } dto.setCreatedAt(resource.getCreatedAt()); dto.setUpdatedAt(resource.getUpdatedAt()); return dto; } // Helper method to convert DTO to entity private Resource convertToEntity(ResourceDTO resourceDTO) { Resource resource = new Resource(); resource.setId(resourceDTO.getId()); resource.setTitle(resourceDTO.getTitle()); resource.setDescription(resourceDTO.getDescription()); resource.setType(resourceDTO.getType()); resource.setUrl(resourceDTO.getUrl()); resource.setFilePath(resourceDTO.getFilePath()); if (resourceDTO.getCourseId() != null) { resource.setCourse(courseService.getCourseById(resourceDTO.getCourseId())); } return resource; } } End File# aakriti0fnu/CourseManagement # api/src/main/java/edu/northeastern/course_management/controller/AssignmentController.java package edu.northeastern.course_management.controller; import edu.northeastern.course_management.dto.AssignmentDTO; import edu.northeastern.course_management.model.Assignment; import edu.northeastern.course_management.service.AssignmentService; import edu.northeastern.course_management.service.CourseService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.time.LocalDateTime; import java.util.List; import java.util.stream.Collectors; @RestController @RequestMapping("/api/assignments") @CrossOrigin(origins = "*") public class AssignmentController { private static final Logger logger = LoggerFactory.getLogger(AssignmentController.class); @Autowired private AssignmentService assignmentService; @Autowired private CourseService courseService; // Get all assignments @GetMapping public ResponseEntity<List> getAllAssignments() { logger.info("Fetching all assignments"); List assignments = assignmentService.getAllAssignments(); List assignmentDTOs = assignments.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(assignmentDTOs); } // Get assignment by ID @GetMapping("/{id}") public ResponseEntity getAssignmentById(@PathVariable Long id) { logger.info("Fetching assignment with ID: {}", id); Assignment assignment = assignmentService.getAssignmentById(id); if (assignment != null) { return ResponseEntity.ok(convertToDTO(assignment)); } else { return ResponseEntity.notFound().build(); } } // Get assignments by course ID @GetMapping("/course/{courseId}") public ResponseEntity<List> getAssignmentsByCourseId(@PathVariable Long courseId) { logger.info("Fetching assignments for course with ID: {}", courseId); List assignments = assignmentService.getAssignmentsByCourseId(courseId); List assignmentDTOs = assignments.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(assignmentDTOs); } // Create a new assignment @PostMapping public ResponseEntity createAssignment(@RequestBody AssignmentDTO assignmentDTO) { logger.info("Creating new assignment: {}", assignmentDTO); Assignment assignment = convertToEntity(assignmentDTO); assignment.setCreatedAt(LocalDateTime.now()); Assignment savedAssignment = assignmentService.createAssignment(assignment); return ResponseEntity.ok(convertToDTO(savedAssignment)); } // Update an assignment @PutMapping("/{id}") public ResponseEntity updateAssignment(@PathVariable Long id, @RequestBody AssignmentDTO assignmentDTO) { logger.info("Updating assignment with ID: {}", id); Assignment existingAssignment = assignmentService.getAssignmentById(id); if (existingAssignment == null) { return ResponseEntity.notFound().build(); } Assignment assignment = convertToEntity(assignmentDTO); assignment.setId(id); assignment.setCreatedAt(existingAssignment.getCreatedAt()); assignment.setUpdatedAt(LocalDateTime.now()); Assignment updatedAssignment = assignmentService.updateAssignment(assignment); return ResponseEntity.ok(convertToDTO(updatedAssignment)); } // Delete an assignment @DeleteMapping("/{id}") public ResponseEntity deleteAssignment(@PathVariable Long id) { logger.info("Deleting assignment with ID: {}", id); Assignment existingAssignment = assignmentService.getAssignmentById(id); if (existingAssignment == null) { return ResponseEntity.notFound().build(); } assignmentService.deleteAssignment(id); return ResponseEntity.noContent().build(); } // Helper method to convert entity to DTO private AssignmentDTO convertToDTO(Assignment assignment) { AssignmentDTO dto = new AssignmentDTO(); dto.setId(assignment.getId()); dto.setTitle(assignment.getTitle()); dto.setDescription(assignment.getDescription()); dto.setDueDate(assignment.getDueDate()); dto.setMaxScore(assignment.getMaxScore()); dto.setCourseId(assignment.getCourse().getId()); dto.setCreatedAt(assignment.getCreatedAt()); dto.setUpdatedAt(assignment.getUpdatedAt()); return dto; } // Helper method to convert DTO to entity private Assignment convertToEntity(AssignmentDTO assignmentDTO) { Assignment assignment = new Assignment(); assignment.setId(assignmentDTO.getId()); assignment.setTitle(assignmentDTO.getTitle()); assignment.setDescription(assignmentDTO.getDescription()); assignment.setDueDate(assignmentDTO.getDueDate()); assignment.setMaxScore(assignmentDTO.getMaxScore()); assignment.setCourse(courseService.getCourseById(assignmentDTO.getCourseId())); return assignment; } } End Filepackage edu.northeastern.course_management.controller; import edu.northeastern.course_management.dto.EnrollmentDTO; import edu.northeastern.course_management.model.Course; import edu.northeastern.course_management.model.Enrollment; import edu.northeastern.course_management.model.User; import edu.northeastern.course_management.service.CourseService; import edu.northeastern.course_management.service.EnrollmentService; import edu.northeastern.course_management.service.UserService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.time.LocalDateTime; import java.util.List; import java.util.stream.Collectors; @RestController @RequestMapping("/api/enrollments") @CrossOrigin(origins = "*") public class EnrollmentController { private static final Logger logger = LoggerFactory.getLogger(EnrollmentController.class); @Autowired private EnrollmentService enrollmentService; @Autowired private UserService userService; @Autowired private CourseService courseService; // Get all enrollments @GetMapping public ResponseEntity<List> getAllEnrollments() { logger.info("Fetching all enrollments"); List enrollments = enrollmentService.getAllEnrollments(); List enrollmentDTOs = enrollments.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(enrollmentDTOs); } // Get enrollment by ID @GetMapping("/{id}") public ResponseEntity getEnrollmentById(@PathVariable Long id) { logger.info("Fetching enrollment with ID: {}", id); Enrollment enrollment = enrollmentService.getEnrollmentById(id); if (enrollment != null) { return ResponseEntity.ok(convertToDTO(enrollment)); } else { return ResponseEntity.notFound().build(); } } // Get enrollments by course ID @GetMapping("/course/{courseId}") public ResponseEntity<List> getEnrollmentsByCourseId(@PathVariable Long courseId) { logger.info("Fetching enrollments for course with ID: {}", courseId); List enrollments = enrollmentService.getEnrollmentsByCourseId(courseId); List enrollmentDTOs = enrollments.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(enrollmentDTOs); } // Get enrollments by student ID @GetMapping("/student/{studentId}") public ResponseEntity<List> getEnrollmentsByStudentId(@PathVariable Long studentId) { logger.info("Fetching enrollments for student with ID: {}", studentId); List enrollments = enrollmentService.getEnrollmentsByStudentId(studentId); List enrollmentDTOs = enrollments.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(enrollmentDTOs); } // Create a new enrollment @PostMapping public ResponseEntity createEnrollment(@RequestBody EnrollmentDTO enrollmentDTO) { logger.info("Creating new enrollment: {}", enrollmentDTO); // Check if the course has reached its enrollment capacity Course course = courseService.getCourseById(enrollmentDTO.getCourseId()); int currentEnrollments = enrollmentService.getEnrollmentsByCourseId(enrollmentDTO.getCourseId()).size(); if (currentEnrollments >= course.getEnrollmentCapacity()) { return ResponseEntity.badRequest().build(); // Course is full } // Check if student is already enrolled if (enrollmentService.isStudentEnrolledInCourse(enrollmentDTO.getStudentId(), enrollmentDTO.getCourseId())) { return ResponseEntity.badRequest().build(); // Student is already enrolled } Enrollment enrollment = convertToEntity(enrollmentDTO); enrollment.setEnrollmentDate(LocalDateTime.now()); enrollment.setStatus("ACTIVE"); Enrollment savedEnrollment = enrollmentService.createEnrollment(enrollment); return ResponseEntity.ok(convertToDTO(savedEnrollment)); } // Update an enrollment @PutMapping("/{id}") public ResponseEntity updateEnrollment(@PathVariable Long id, @RequestBody EnrollmentDTO enrollmentDTO) { logger.info("Updating enrollment with ID: {}", id); Enrollment existingEnrollment = enrollmentService.getEnrollmentById(id); if (existingEnrollment == null) { return ResponseEntity.notFound().build(); } Enrollment enrollment = convertToEntity(enrollmentDTO); enrollment.setId(id); enrollment.setEnrollmentDate(existingEnrollment.getEnrollmentDate()); Enrollment updatedEnrollment = enrollmentService.updateEnrollment(enrollment); return ResponseEntity.ok(convertToDTO(updatedEnrollment)); } // Delete an enrollment @DeleteMapping("/{id}") public ResponseEntity deleteEnrollment(@PathVariable Long id) { logger.info("Deleting enrollment with ID: {}", id); Enrollment existingEnrollment = enrollmentService.getEnrollmentById(id); if (existingEnrollment == null) { return ResponseEntity.notFound().build(); } enrollmentService.deleteEnrollment(id); return ResponseEntity.noContent().build(); } // Check if a student is enrolled in a course @GetMapping("/check/{studentId}/{courseId}") public ResponseEntity isStudentEnrolled(@PathVariable Long studentId, @PathVariable Long courseId) { logger.info("Checking if student {} is enrolled in course {}", studentId, courseId); boolean isEnrolled = enrollmentService.isStudentEnrolledInCourse(studentId, courseId); return ResponseEntity.ok(isEnrolled); } // Helper method to convert entity to DTO private EnrollmentDTO convertToDTO(Enrollment enrollment) { EnrollmentDTO dto = new EnrollmentDTO(); dto.setId(enrollment.getId()); dto.setStudentId(enrollment.getStudent().getId()); dto.setStudentName(enrollment.getStudent().getFirstName() + " " + enrollment.getStudent().getLastName()); dto.setCourseId(enrollment.getCourse().getId()); dto.setCourseName(enrollment.getCourse().getTitle()); dto.setEnrollmentDate(enrollment.getEnrollmentDate()); dto.setStatus(enrollment.getStatus()); dto.setGrade(enrollment.getGrade()); dto.setCompletionDate(enrollment.getCompletionDate()); return dto; } // Helper method to convert DTO to entity private Enrollment convertToEntity(EnrollmentDTO enrollmentDTO) { Enrollment enrollment = new Enrollment(); enrollment.setId(enrollmentDTO.getId()); User student = userService.getUserById(enrollmentDTO.getStudentId()); enrollment.setStudent(student); Course course = courseService.getCourseById(enrollmentDTO.getCourseId()); enrollment.setCourse(course); enrollment.setEnrollmentDate(enrollmentDTO.getEnrollmentDate()); enrollment.setStatus(enrollmentDTO.getStatus()); enrollment.setGrade(enrollmentDTO.getGrade()); enrollment.setCompletionDate(enrollmentDTO.getCompletionDate()); return enrollment; } } End File# aakriti0fnu/CourseManagement package edu.northeastern.course_management.controller; import edu.northeastern.course_management.dto.SubmissionDTO; import edu.northeastern.course_management.model.Submission; import edu.northeastern.course_management.service.AssignmentService; import edu.northeastern.course_management.service.SubmissionService; import edu.northeastern.course_management.service.UserService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.time.LocalDateTime; import java.util.List; import java.util.stream.Collectors; @RestController @RequestMapping("/api/submissions") @CrossOrigin(origins = "*") public class SubmissionController { private static final Logger logger = LoggerFactory.getLogger(SubmissionController.class); @Autowired private SubmissionService submissionService; @Autowired private AssignmentService assignmentService; @Autowired private UserService userService; // Get all submissions @GetMapping public ResponseEntity<List> getAllSubmissions() { logger.info("Fetching all submissions"); List submissions = submissionService.getAllSubmissions(); List submissionDTOs = submissions.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(submissionDTOs); } // Get submission by ID @GetMapping("/{id}") public ResponseEntity getSubmissionById(@PathVariable Long id) { logger.info("Fetching submission with ID: {}", id); Submission submission = submissionService.getSubmissionById(id); if (submission != null) { return ResponseEntity.ok(convertToDTO(submission)); } else { return ResponseEntity.notFound().build(); } } // Get submissions by assignment ID @GetMapping("/assignment/{assignmentId}") public ResponseEntity<List> getSubmissionsByAssignmentId(@PathVariable Long assignmentId) { logger.info("Fetching submissions for assignment with ID: {}", assignmentId); List submissions = submissionService.getSubmissionsByAssignmentId(assignmentId); List submissionDTOs = submissions.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(submissionDTOs); } // Get submissions by student ID @GetMapping("/student/{studentId}") public ResponseEntity<List> getSubmissionsByStudentId(@PathVariable Long studentId) { logger.info("Fetching submissions for student with ID: {}", studentId); List submissions = submissionService.getSubmissionsByStudentId(studentId); List submissionDTOs = submissions.stream() .map(this::convertToDTO) .collect(Collectors.toList()); return ResponseEntity.ok(submissionDTOs); } // Get submission by assignment ID and student ID @GetMapping("/assignment/{assignmentId}/student/{studentId}") public ResponseEntity getSubmissionByAssignmentAndStudentId( @PathVariable Long assignmentId, @PathVariable Long studentId) { logger.info("Fetching submission for assignment ID: {} and student ID: {}", assignmentId, studentId); Submission submission = submissionService.getSubmissionByAssignmentAndStudentId(assignmentId, studentId); if (submission != null) { return ResponseEntity.ok(convertToDTO(submission)); } else { return ResponseEntity.notFound().build(); } } // Create a new submission @PostMapping public ResponseEntity createSubmission(@RequestBody SubmissionDTO submissionDTO) { logger.info("Creating new submission: {}", submissionDTO); // Check if the student already has a submission for this assignment Submission existingSubmission = submissionService.getSubmissionByAssignmentAndStudentId( submissionDTO.getAssignmentId(), submissionDTO.getStudentId()); if (existingSubmission != null) { // Update the existing submission instead of creating a new one existingSubmission.setContent(submissionDTO.getContent()); existingSubmission.setFilePath(submissionDTO.getFilePath()); existingSubmission.setSubmissionDate(LocalDateTime.now()); existingSubmission.setUpdatedAt(LocalDateTime.now()); Submission updatedSubmission = submissionService.updateSubmission(existingSubmission); return ResponseEntity.ok(convertToDTO(updatedSubmission)); } Submission submission = convertToEntity(submissionDTO); submission.setSubmissionDate(LocalDateTime.now()); submission.setCreatedAt(LocalDateTime.now()); Submission savedSubmission = submissionService.createSubmission(submission); return ResponseEntity.ok(convertToDTO(savedSubmission)); } // Update a submission @PutMapping("/{id}") public ResponseEntity updateSubmission(@PathVariable Long id, @RequestBody SubmissionDTO submissionDTO) { logger.info("Updating submission with ID: {}", id); Submission existingSubmission = submissionService.getSubmissionById(id); if (existingSubmission == null) { return ResponseEntity.notFound().build(); } Submission submission = convertToEntity(submissionDTO); submission.setId(id); submission.setCreatedAt(existingSubmission.getCreatedAt()); submission.setUpdatedAt(LocalDateTime.now()); Submission updatedSubmission = submissionService.updateSubmission(submission); return ResponseEntity.ok(convertToDTO(updatedSubmission)); } // Grade a submission @PutMapping("/{id}/grade") public ResponseEntity gradeSubmission( @PathVariable Long id, @RequestParam Double score, @RequestParam(required = false) String feedback) { logger.info("Grading submission with ID: {}", id); Submission submission = submissionService.getSubmissionById(id); if (submission == null) { return ResponseEntity.notFound().build(); } // Validate that score is not greater than max score for the assignment if (score > submission.getAssignment().getMaxScore()) { return ResponseEntity.badRequest().build(); } submission.setScore(score); submission.setFeedback(feedback); submission.setGradedAt(LocalDateTime.now()); submission.setUpdatedAt(LocalDateTime.now()); Submission gradedSubmission = submissionService.updateSubmission(submission); return ResponseEntity.ok(convertToDTO(gradedSubmission)); } // Delete a submission @DeleteMapping("/{id}") public ResponseEntity deleteSubmission(@PathVariable Long id) { logger.info("Deleting submission with ID: {}", id); Submission existingSubmission = submissionService.getSubmissionById(id); if (existingSubmission == null) { return ResponseEntity.notFound().build(); } submissionService.deleteSubmission(id); return ResponseEntity.noContent().build(); } // Helper method to convert entity to DTO private SubmissionDTO convertToDTO(Submission submission) { SubmissionDTO dto = new SubmissionDTO(); dto.setId(submission.getId()); dto.setAssignmentId(submission.getAssignment().getId()); dto.setAssignmentTitle(submission.getAssignment().getTitle()); dto.setStudentId(submission.getStudent().getId()); dto.setStudentName(submission.getStudent().getFirstName() + " " + submission.getStudent().getLastName()); dto.setContent(submission.getContent()); dto.setFilePath(submission.getFilePath()); dto.setSubmissionDate(submission.getSubmissionDate()); dto.setScore(submission.getScore()); dto.setFeedback(submission.getFeedback()); dto.setGradedAt(submission.getGradedAt()); dto.setCreatedAt(submission.getCreatedAt()); dto.setUpdatedAt(submission.getUpdatedAt()); return dto; } // Helper method to convert DTO to entity private Submission convertToEntity(SubmissionDTO submissionDTO) { Submission submission = new Submission(); submission.setId(submissionDTO.getId()); submission.setAssignment(assignmentService.getAssignmentById(submissionDTO.getAssignmentId())); submission.setStudent(userService.getUserById(submissionDTO.getStudentId())); submission.setContent(submissionDTO.getContent()); submission.setFilePath(submissionDTO.getFilePath()); submission.setSubmissionDate(submissionDTO.getSubmissionDate()); submission.setScore(submissionDTO.getScore()); submission.setFeedback(submissionDTO.getFeedback()); submission.setGradedAt(submissionDTO.getGradedAt()); return submission; } } End File#

Kde najdeme nejlepší místní produkty na Thassosu?

Na Thassosu objevíte kvalitní místní produkty prakticky ve všech turistických centrech ostrova. Nejautentičtější zážitek z nakupování ale nabízejí lokální trhy v tradičních horských vesničkách jako Panagia, Potamia nebo Theologos. Právě tady nakoupíte přímo od výrobců prvotřídní olivový olej, med z thymiánu, medové likéry a tradiční sladkosti. Ve městě Thassos (Limenas) doporučujeme navštívit centrální tržnici, která funguje nejživěji během dopoledních hodin. V přímořských letoviscích jako Limenaria, Potos nebo Skala Potamia najdete specializované obchůdky zaměřené na lokální delikatesy. Nejčerstvější ovoce a zeleninu koupíte na okrajích měst od místních farmářů, kteří často prodávají úrodu přímo ze svých vozíků – poznáte je podle ručně psaných cedulí podél hlavních silnic.

Jaké suvenýry si máme z Thassosu přivézt?

Thassos nabízí celou řadu autentických suvenýrů, které stojí za odvoz domů. Na prvním místě doporučujeme vyhlášený thassoský med, který má jedinečnou chuť díky rozmarýnu a thymiánu rostoucímu na ostrově. Neméně slavný je místní extra panenský olivový olej ze staletých olivových hájů. Milovníci kulinářských zážitků ocení domácí olivové pasty, nakládané speciality a místní koření. Z alkoholických nápojů patří k vyhlášeným rakomélo (teplý nápoj z raki a medu), ouzo nebo medové likéry. Za pozornost stojí také ručně vyráběné keramické výrobky, dřevěné předměty z olivového dřeva a tradiční textilie s lokálními vzory. V horských vesničkách můžete narazit na umělecká díla místních řemeslníků – malované kameny, šperky či ručně tkaná prostírání. Většina obchodů nabízí balení vhodné pro leteckou přepravu.

Kolik stojí potraviny na Thassosu ve srovnání s Českem?

Ceny základních potravin na Thassosu jsou srovnatelné nebo mírně vyšší než v České republice. V supermarketech můžete očekávat podobné ceny jako u nás, v menších lokálních obchodech pak o 10-20 % vyšší. Za základní potraviny jako chléb (asi 1-1,5 €), mléko (1,8-2 € za litr) nebo vejce (2-3 € za 10 ks) zaplatíte podobně jako v Česku. Výrazně levnější jsou místní produkty, zejména čerstvé ovoce a zelenina v sezóně – například kilo rajčat pořídíte za 1-2 €, melouny za 0,5-1 € za kilo. Naopak dovážené potraviny (zejména maso, sýry, zpracované potraviny) bývají dražší. Místní alkohol jako ouzo či domácí víno je cenově dostupný (3-8 € za lahev), zatímco importované značky jsou výrazně dražší než v ČR. Pro nejlepší poměr ceny a kvality doporučujeme nakupovat v supermarketech řetězců Masoutis nebo Sklavenitis, které najdete ve větších městech ostrova.

Kdy jsou otevřené obchody na Thassosu?

Provozní doba obchodů na Thassosu se liší podle sezóny a typu obchodu. Během hlavní turistické sezóny (červen-září) jsou supermarkety a obchody se suvenýry otevřené téměř nepřetržitě – většinou od 8:00 do 22:00 nebo i déle, a to často sedm dní v týdnu. Menší obchody s potravinami (tzv. mini markety) v turistických oblastech fungují obvykle od 7:30 do pozdních večerních hodin. Pozor však na tradiční řeckou siestu – mimo hlavní sezónu mnoho obchodů zavírá mezi 14:00-17:00 a poté znovu otevírá až do 21:00. Specializované obchody v menších vesnicích mohou mít omezenější otevírací dobu, zejména mimo sezónu. Místní pekárny otevírají velmi brzy, už kolem 6:00 ráno. V neděli bývá otevřeno méně obchodů, i když v turistických centrech najdete dostatek otevřených marketů. Během státních svátků a náboženských oslav mohou být obchody zcela zavřené nebo mít zkrácenou otevírací dobu.

Je na Thassosu možné platit kartou?

Platba kartou je na Thassosu stále rozšířenější, ale její akceptace není zdaleka tak univerzální jako v České republice. Ve větších supermarketech, hotelech, restauracích a turisticky orientovaných obchodech můžete bez problémů platit kartami Visa a Mastercard. American Express bývá akceptována méně často. Menší lokální obchody, tradiční taverny a stánky na trzích však často upřednostňují hotovost. Na ostrově je dostatek bankomatů, zvláště v turistických oblastech jako Limenas, Limenaria, Potos a Skala Potamia. Při výběru z bankomatu se mohou účtovat poplatky, proto doporučujeme vybírat větší částky najednou. Mnoho obchodníků také může stanovit minimální částku pro platbu kartou (obvykle kolem 10-20 €). Pro jistotu doporučujeme mít vždy u sebe nějakou hotovost, zvláště pokud se chystáte navštívit odlehlejší vesnice nebo méně turistická místa. Platební terminály mohou být občas mimo provoz, zejména na začátku a konci sezóny.

Kde najdeme nejlepší trhy s čerstvými potravinami?

Nejlepší tržiště s čerstvými potravinami najdete ve městě Thassos (Limenas), kde se koná pravidelný trh každé pondělí a čtvrtek dopoledne poblíž přístavu. Tady seženete vše od čerstvého ovoce a zeleniny po ryby, sýry, olivy a bylinky přímo od místních farmářů. V Potamiě funguje menší farmářský trh každou středu, který nabízí vynikající kvalitu za příznivé ceny. Limenaria má svůj trh v pátek dopoledne, a to zejména v hlavní sezóně. Kromě organizovaných trhů stojí za pozornost pojízdní prodejci, kteří parkují svá auta podél hlavních silnic a prodávají sezónní produkty – v létě zejména melouny, broskve a rajčata, na podzim pak ořechy, olivy a citrusy. Pro rybí speciality navštivte malé rybí trhy v přístavních městech (Skala Prinos, Limenas), kde můžete koupit čerstvý úlovek přímo od rybářů, obvykle časně ráno. V horských vesničkách jako Panagia nebo Kazaviti najdete malé rodinné krámky s domácími produkty, které sice nejsou formálně trhy, ale nabízí autentické lokální potraviny.

Kde seženeme na Thassosu nejlevnější potraviny?

Pro nejlevnější nákupy potravin na Thassosu doporučujeme navštívit větší supermarkety řetězců jako Masoutis, Sklavenitis nebo Lidl, které najdete ve městech Limenas (Thassos) a Limenaria. Tyto řetězce nabízejí nejlepší poměr ceny a kvality, pravidelné akční nabídky a širší sortiment. Zvláště supermarket Lidl na okraji Limenarie je oblíbený mezi návštěvníky hledajícími úspornější varianty nákupů. Dalším tipem jsou místní farmářské trhy, které se konají v různých městech (Limenas, Limenaria, Potamia) – zde nakoupíte čerstvé ovoce a zeleninu přímo od pěstitelů za výhodné ceny. Pokud jedete autem, všimněte si prodejců u silnic, kteří nabízejí sezónní produkty za zlomek cen v obchodech. Vyplatí se také nakupovat v menších obchodech s potravinami na okraji měst nebo v méně turistických oblastech, kde bývají ceny nižší než v centrech letovisek. V případě balených potravin a nápojů jsou obecně nejlevnější větší rodinná balení, která najdete v supermarketech.

Jaké jsou typické thassoské potraviny, které stojí za nákup?

Thassos nabízí řadu jedinečných potravin, které stojí za odvoz domů. Bezkonkurenčně nejslavnějším produktem je thassoský med, charakteristický svou hustou texturou a aromatickou chutí díky místnímu tymiánu a borovicovým lesům. Na stejné úrovni je prémiový olivový olej z prastarých olivových hájů ostrova, často prodávaný v elegantních lahvích vhodných jako dárek. Z dalších specialit doporučujeme ochutnat a přivézt:

• Thasítiko tyri – místní kozí sýr s charakteristickou pikantní chutí
• Pasteli – tradiční řecká sladkost z medu a sezamových semínek
• Sušené bylinky – zejména oregano, tymián a šalvěj
• Domácí marmelády – nejčastěji z fíků, pomerančů nebo bergamotu
• Nakládané speciality – olivy všech druhů, sušená rajčata, kapary
• Pistácie a mandle – místní odrůdy jsou zvláště chutné
• Ouzo a rakomélo – tradiční alkoholické nápoje

Tyto produkty najdete v specializovaných obchodech s delikatesami v turistických centrech i v malých rodinných provozovnách ve vnitrozemských vesnicích.

Jaké obchody s oblečením a módou na Thassosu navštívit?

Thassos není primárně módní destinací, ale nabízí pestrou škálu obchodů s oblečením, zvláště v hlavních turistických centrech. Největší koncentrace módních butiků je v Limenas (hlavní město), především v okolí přístavu a na hlavních pěších zónách. Najdete zde jak řecké, tak mezinárodní značky střední cenové kategorie. V Limenarii, druhém největším městě, se nachází několik elegantních butiků s plážovou módou a letním oblečením podél hlavní promenády. V turistických letoviscích jako Potos, Skala Prinou a Golden Beach objevíte menší obchody zaměřené na plážové oblečení, plavky a módní doplňky. Pro milovníky tradičního řeckého stylu doporučujeme butiky ve vesnici Panagia, kde najdete ručně vyráběné oděvy z přírodních materiálů. Místní trhy občas nabízejí zajímavé kousky za příznivé ceny, i když kvalita může být kolísavá. Pro značkové oblečení za rozumné ceny doporučujeme nákupní centrum v Kavale na pevnině, které je dostupné trajektem z Thassosu (plavba trvá zhruba hodinu).

Kde koupit kvalitní thassoský olivový olej a med?

Pro nákup skutečně kvalitního thassoského olivového oleje a medu doporučujeme vyhnout se běžným turistickým obchodům a zamířit přímo ke zdroji. Nejautentičtější produkty najdete v horských vesničkách, kde místní rodiny pokračují v tradičních výrobních postupech již po generace. Vesnice Panagia je známá svými olivovými háji a několika rodinnými lisovnami, kde si můžete prohlédnout výrobu a zakoupit čerstvě lisovaný extra panenský olivový olej. Místní včelaři ve vesnicích Theologos a Potamia nabízejí různé druhy medu včetně vzácného thymiánového a borovicového. Za návštěvu stojí také specializované obchody s farmářskými produkty v Limenas a Limenarii, kde často nabízejí ochutnávky před nákupem. Další možností jsou družstevní prodejny, například Women's Agricultural Cooperative v Prinou, kde místní ženy prodávají med, olej a další domácí produkty. Pro zaručenou kvalitu hledejte označení PDO (Protected Designation of Origin) na olivovém oleji. Ceny kvalitního extra panenského oleje se pohybují od 8-15 € za 500 ml, prvotřídní med pak 8-12 € za 450 g, v závislosti na druhu a místu nákupu.

Jsou na Thassosu nějaká nákupní centra?

Na Thassosu nenajdete klasická velká nákupní centra, jak je známe z České republiky nebo jiných evropských destinací. Ostrov si zachovává spíše tradiční ráz s menšími samostatnými obchody a butiky rozmístěnými podél hlavních ulic a náměstí. Největší koncentraci obchodů nabízí hlavní město Limenas (Thassos Town), kde se podél přístavu a v přilehlých uličkách nachází mnoho butiků, suvenýrových obchodů a potravinářských prodejen. Podobně v Limenarii, druhém největším městě ostrova, najdete obchodní zónu táhnoucí se podél pobřežní promenády. V turistických letoviscích jako Potos, Golden Beach nebo Skala Prinou existují menší nákupní zóny s obchody zaměřenými na turisty. Pokud toužíte po klasickém nákupním centru s velkými mezinárodními značkami, budete muset navštívit město Kavala na pevnině, kde se nachází několik nákupních center včetně Kavala Shopping Center. Do Kavaly se pohodlně dostanete trajektem z přístavu Skala Prinou, cesta trvá přibližně hodinu.