Job Posting Functionality Implementation

src/main/java/com/activecourses/upwork/controller/job/JobController.java

@@ -0,0 +1,52 @@
+package com.activecourses.upwork.controller.job;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import com.activecourses.upwork.dto.JobDTO;
+import com.activecourses.upwork.dto.ResponseDto;
+import com.activecourses.upwork.mapper.JobMapper;
+import com.activecourses.upwork.model.Job;
+import com.activecourses.upwork.service.job.JobService;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+
+@Tag(name = "Job", description = "Job Management API")
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/jobs/")
+public class JobController {
+    private final JobService jobService;
+    private final JobMapper jobMapper;
+
+    @Operation(
+            summary = "Create a new job",
+            description = "Creates a new job posting",
+            security = @SecurityRequirement(name = "bearerAuth")
+    )
+    @PreAuthorize("hasRole('ADMIN') or hasRole('CLIENT') or hasRole('FREELANCER')")
+    @PostMapping("/post")
+    public ResponseEntity<ResponseDto> createJob(@RequestBody JobDTO jobDTO) {
+        Job createdJob = jobService.createJob(jobDTO);
+        return buildResponseEntity(HttpStatus.CREATED, true, jobMapper.mapTo(createdJob), null);
+    }
+
+    private ResponseEntity<ResponseDto> buildResponseEntity(
+            HttpStatus status, boolean success, Object data, Object error) {
+        return ResponseEntity
+                .status(status)
+                .body(ResponseDto
+                        .builder()
+                        .status(status)
+                        .success(success)
+                        .data(data)
+                        .error(error)
+                        .build()
+                );
+    }
+}

src/main/java/com/activecourses/upwork/dto/JobDTO.java

@@ -0,0 +1,17 @@
+package com.activecourses.upwork.dto;
+
+import java.math.BigDecimal;
+import java.util.Set;
+
+import com.activecourses.upwork.model.JobType;
+
+import lombok.Data;
+
+@Data
+public class JobDTO {
+    private String title;
+    private String description;
+    private BigDecimal budget;
+    private JobType jobType;
+    private Set<Integer> skillIds;
+}

src/main/java/com/activecourses/upwork/mapper/JobMapper.java

@@ -0,0 +1,32 @@
+package com.activecourses.upwork.mapper;
+
+import org.springframework.stereotype.Component;
+
+import com.activecourses.upwork.dto.JobDTO;
+import com.activecourses.upwork.model.Job;
+import com.activecourses.upwork.model.JobStatus;
+
+@Component
+public class JobMapper implements Mapper<Job, JobDTO> {
+
+    @Override
+    public JobDTO mapTo(Job job) {
+        JobDTO jobDTO = new JobDTO();
+        jobDTO.setTitle(job.getTitle());
+        jobDTO.setDescription(job.getDescription());
+        jobDTO.setBudget(job.getBudget());
+        jobDTO.setJobType(job.getJobType());
+        return jobDTO;
+    }
+
+    @Override
+    public Job mapFrom(JobDTO jobDTO) {
+        Job job = new Job();
+        job.setTitle(jobDTO.getTitle());
+        job.setDescription(jobDTO.getDescription());
+        job.setBudget(jobDTO.getBudget());
+        job.setJobType(jobDTO.getJobType());
+        job.setStatus(JobStatus.Open); // Default status
+        return job;
+    }
+}

src/main/java/com/activecourses/upwork/model/Job.java

@@ -0,0 +1,60 @@
+package com.activecourses.upwork.model;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.Set;
+
+import jakarta.persistence.*;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@Entity
+@Table(name = "jobs")
+public class Job {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer jobId;
+
+    @ManyToOne
+    @JoinColumn(name = "client_id")
+    private User client;
+
+    @Column(nullable = false, length = 255)
+    private String title;
+
+    @Column(nullable = false, columnDefinition = "TEXT")
+    private String description;
+
+    @Column(nullable = false)
+    private BigDecimal budget;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private JobType jobType;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private JobStatus status;
+
+    @Builder.Default
+    @Column(nullable = false, updatable = false)
+    private LocalDateTime createdAt = LocalDateTime.now();
+
+    @ManyToMany
+    @JoinTable(
+            name = "job_skills",
+            joinColumns = @JoinColumn(name = "job_id"),
+            inverseJoinColumns = @JoinColumn(name = "skill_id")
+    )
+    private Set<Skill> skills;
+}

src/main/java/com/activecourses/upwork/model/JobStatus.java

@@ -0,0 +1,8 @@
+package com.activecourses.upwork.model;
+
+public enum JobStatus {
+    Open,
+    Closed,
+    InProgress;
+
+}

src/main/java/com/activecourses/upwork/model/JobType.java

@@ -0,0 +1,7 @@
+package com.activecourses.upwork.model;
+
+public enum JobType {
+    Hourly,
+    Fixed;
+
+}

src/main/java/com/activecourses/upwork/model/Skill.java

@@ -0,0 +1,33 @@
+package com.activecourses.upwork.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Set;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+@Entity
+@Table(name = "skills")
+public class Skill {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "skill_id")
+    private Integer id;
+
+    @Column(name = "skill_name", nullable = false, unique = true, length = 50)
+    private String name;
+
+    @ManyToMany(mappedBy = "skills")
+    private Set<Job> jobs;
+
+    @ManyToMany(mappedBy = "skills")
+    private Set<UserProfile> userProfiles;
+}

src/main/java/com/activecourses/upwork/model/UserProfile.java

@@ -8,6 +8,7 @@
 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
 
 import java.math.BigDecimal;
+import java.util.Set;
 
 @Data
 @NoArgsConstructor
@@ -35,4 +36,11 @@ public class UserProfile {
     @JoinColumn(name = "user_id", unique = true)
     private User user;
 
+    @ManyToMany
+    @JoinTable(
+            name = "user_skills",
+            joinColumns = @JoinColumn(name = "user_id"),
+            inverseJoinColumns = @JoinColumn(name = "skill_id")
+    )
+    private Set<Skill> skills;
 }

src/main/java/com/activecourses/upwork/repository/job/JobRepository.java

@@ -0,0 +1,10 @@
+package com.activecourses.upwork.repository.job;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import com.activecourses.upwork.model.Job;
+
+@Repository
+public interface JobRepository extends JpaRepository<Job, Integer> {
+
+}

src/main/java/com/activecourses/upwork/repository/skill/SkillRepository.java

@@ -0,0 +1,11 @@
+package com.activecourses.upwork.repository.skill;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import com.activecourses.upwork.model.Skill;
+
+@Repository
+public interface SkillRepository extends JpaRepository<Skill, Integer> {
+
+}

src/main/java/com/activecourses/upwork/service/authentication/AuthService.java

@@ -23,4 +23,6 @@ public interface AuthService {
     boolean deactivateUser(int userId);
 
     boolean reactivateUser(int userId);
+
+    Integer getCurrentUserId();
 }

src/main/java/com/activecourses/upwork/service/authentication/AuthServiceImpl.java

@@ -202,6 +202,17 @@ public boolean reactivateUser(int userId) {
         return true;
     }
 
+    @Override
+    public Integer getCurrentUserId() {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        if (authentication != null && authentication.isAuthenticated()) {
+            UserDetails userDetails = (UserDetails) authentication.getPrincipal();
+            User user = (User) userDetails;
+            return user.getId();
+        }
+        return null;
+    }
+
     static User unwrapUser(Optional<User> entity) {
         if (entity.isPresent()) {
             return entity.get();

src/main/java/com/activecourses/upwork/service/job/JobService.java

@@ -0,0 +1,8 @@
+package com.activecourses.upwork.service.job;
+
+import com.activecourses.upwork.dto.JobDTO;
+import com.activecourses.upwork.model.Job;
+
+public interface JobService {
+    Job createJob(JobDTO jobDTO);
+}

src/main/java/com/activecourses/upwork/service/job/JobServiceImpl.java

@@ -0,0 +1,54 @@
+package com.activecourses.upwork.service.job;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.springframework.stereotype.Service;
+
+import com.activecourses.upwork.dto.JobDTO;
+import com.activecourses.upwork.mapper.JobMapper;
+import com.activecourses.upwork.model.Job;
+import com.activecourses.upwork.model.Skill;
+import com.activecourses.upwork.model.User;
+import com.activecourses.upwork.repository.job.JobRepository;
+import com.activecourses.upwork.repository.skill.SkillRepository;
+import com.activecourses.upwork.repository.user.UserRepository;
+import com.activecourses.upwork.service.authentication.AuthService;
+
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class JobServiceImpl implements JobService {
+
+    private final JobRepository jobRepository;
+    private final UserRepository userRepository;
+    private final AuthService authService;
+    private final JobMapper jobMapper;
+    private final SkillRepository skillRepository;
+
+    @Override
+    public Job createJob(JobDTO jobDTO) {
+        Integer clientId = authService.getCurrentUserId();
+        if (clientId == null) {
+            throw new IllegalStateException("User is not authenticated");
+        }
+
+        User client = userRepository.findById(clientId)
+                .orElseThrow(() -> new IllegalArgumentException("User not found with ID: " + clientId));
+
+        Job job = jobMapper.mapFrom(jobDTO);
+
+        Set<Skill> skills = new HashSet<>();
+        for (Integer skillId : jobDTO.getSkillIds()) {
+            skills.add(skillRepository.findById(skillId)
+                    .orElseThrow(() -> new IllegalArgumentException("Skill not found: " + skillId)));
+        }
+        job.setSkills(skills);
+
+        job.setClient(client);
+
+        return jobRepository.save(job);
+    }
+
+}

src/main/java/com/activecourses/upwork/service/role/RoleServiceImpl.java

@@ -58,10 +58,17 @@ public boolean assignRolesToUser(int userId, Map<String, Object> roles) {
         logger.info("Assigning roles to user with id: {}", userId);
         Optional<User> user = userRepository.findById(userId);
         User unwrappedUser = user.orElseThrow(() -> new RuntimeException("User not found: " + userId));
-        List<Role> roleList = roles.keySet().stream()
+
+        // Extract role names from the request body
+        List<String> roleNames = (List<String>) roles.get("roles");
+
+        // Fetch roles from the database
+        List<Role> roleList = roleNames.stream()
                 .map(roleName -> roleRepository.findByName(roleName)
                         .orElseThrow(() -> new RuntimeException("Role not found: " + roleName)))
                 .collect(Collectors.toList());
+
+        // Assign roles to the user
         unwrappedUser.setRoles(roleList);
         userRepository.save(unwrappedUser);
         return true;

src/main/resources/db/migration/V6__Add_test_skills.sql

@@ -0,0 +1,8 @@
+-- V6__Add_test_skills.sql
+
+-- Insert sample skills for testing purposes
+INSERT INTO skills (skill_name) VALUES 
+('Java'),
+('Spring Boot'),
+('Angular'),
+('PostgreSQL');