Capstone Project

smarttask-api/
├── src/main/java/com/campustoai/smarttask/
│   ├── SmartTaskApplication.java          // @SpringBootApplication
│   ├── config/
│   │   ├── SecurityConfig.java            // JWT filter, CORS config
│   │   └── AiConfig.java                  // LangChain4j bean setup
│   ├── model/
│   │   ├── User.java                      // @Entity
│   │   ├── Task.java                      // @Entity, @ManyToOne User
│   │   └── SubTask.java                   // @Entity, @ManyToOne Task
│   ├── repository/
│   │   ├── UserRepository.java
│   │   ├── TaskRepository.java
│   │   └── SubTaskRepository.java
│   ├── service/
│   │   ├── AuthService.java
│   │   ├── TaskService.java
│   │   └── AiSuggestionService.java       // Calls LangChain4j
│   └── controller/
│       ├── AuthController.java            // POST /api/auth/register, /login
│       ├── TaskController.java            // CRUD /api/tasks
│       └── AiController.java              // POST /api/tasks/{id}/suggest
└── src/main/resources/
    └── application.properties

@Entity
@Table(name = "tasks")
public class Task {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String title;

    private String description;

    @Enumerated(EnumType.STRING)
    private TaskStatus status = TaskStatus.TODO;  // TODO, IN_PROGRESS, DONE

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id")
    private User user;

    @OneToMany(mappedBy = "task", cascade = CascadeType.ALL)
    private List<SubTask> subTasks = new ArrayList<>();

    @CreationTimestamp
    private LocalDateTime createdAt;

    // Getters + Setters (or use Lombok @Data)
}

@RestController
@RequestMapping("/api/tasks")
public class TaskController {

    private final TaskService taskService;

    public TaskController(TaskService taskService) {
        this.taskService = taskService;
    }

    @GetMapping
    public List<TaskDTO> getAllTasks(@AuthenticationPrincipal UserDetails user) {
        return taskService.getTasksForUser(user.getUsername());
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public TaskDTO createTask(@RequestBody CreateTaskRequest req,
                               @AuthenticationPrincipal UserDetails user) {
        return taskService.createTask(req, user.getUsername());
    }

    @PutMapping("/{id}")
    public TaskDTO updateTask(@PathVariable Long id,
                               @RequestBody UpdateTaskRequest req) {
        return taskService.updateTask(id, req);
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteTask(@PathVariable Long id) {
        taskService.deleteTask(id);
    }
}

smarttask-ui/
├── src/
│   ├── api/
│   │   └── axiosInstance.ts      // Base URL + JWT header interceptor
│   ├── pages/
│   │   ├── LoginPage.tsx
│   │   ├── DashboardPage.tsx     // List of all tasks
│   │   └── TaskDetailPage.tsx    // Single task + AI suggestions
│   ├── components/
│   │   ├── TaskCard.tsx
│   │   ├── SubTaskList.tsx
│   │   └── Navbar.tsx
│   ├── types/
│   │   └── index.ts              // Task, SubTask, User interfaces
│   └── App.tsx                   // React Router routes
├── Dockerfile                    // Build + serve with NGINX
└── vite.config.ts

// src/api/axiosInstance.ts
import axios from 'axios';

const api = axios.create({
  baseURL: import.meta.env.VITE_API_URL ?? 'http://localhost:8080',
});

// Automatically attach the JWT token to every request
api.interceptors.request.use((config) => {
  const token = localStorage.getItem('token');
  if (token) {
    config.headers.Authorization = `Bearer ${token}`;
  }
  return config;
});

export default api;

// src/pages/DashboardPage.tsx
import { useEffect, useState } from 'react';
import api from '../api/axiosInstance';
import { Task } from '../types';

export default function DashboardPage() {
  const [tasks, setTasks] = useState<Task[]>([]);

  useEffect(() => {
    api.get<Task[]>('/api/tasks')
       .then(res => setTasks(res.data))
       .catch(err => console.error(err));
  }, []);

  return (
    <div className="dashboard">
      <h1>My Tasks</h1>
      {tasks.map(task => (
        <div key={task.id} className="task-card">
          <h3>{task.title}</h3>
          <span className={`status ${task.status.toLowerCase()}`}>{task.status}</span>
        </div>
      ))}
    </div>
  );
}

// AiSuggestionService.java
@Service
public class AiSuggestionService {

    private final TaskAssistant assistant;  // LangChain4j @AiService

    public List<String> suggestSubTasks(String taskTitle) {
        String response = assistant.breakDownTask(taskTitle);
        // Response is a numbered list like "1. Research topic\n2. Create outline\n..."
        return Arrays.stream(response.split("\\n"))
                     .filter(line -> !line.isBlank())
                     .map(line -> line.replaceAll("^\\d+\\.\\s*", ""))
                     .collect(Collectors.toList());
    }
}

// TaskAssistant.java
@AiService
public interface TaskAssistant {

    @SystemMessage("""
        You are a productivity coach helping software developers.
        When given a task title, break it into 5 clear, actionable sub-tasks.
        Return ONLY a numbered list. No extra text or explanation.
        """)
    String breakDownTask(@UserMessage String taskTitle);
}

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
    <version>0.32.0</version>
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
    <version>0.32.0</version>
</dependency>

langchain4j.open-ai.chat-model.api-key=${OPENAI_API_KEY}
langchain4j.open-ai.chat-model.model-name=gpt-4o-mini
langchain4j.open-ai.chat-model.temperature=0.3
langchain4j.open-ai.chat-model.max-tokens=500

# Backend Dockerfile (multi-stage)
FROM eclipse-temurin:21-jdk-alpine AS builder
WORKDIR /app
COPY . .
RUN ./mvnw clean package -DskipTests

FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
COPY --from=builder /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

# Frontend Dockerfile
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json .
RUN npm ci
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80

# Login to Azure
az login
az acr login --name smarttaskacr

# Tag and push backend image
docker build -t smarttask-api ./smarttask-api
docker tag smarttask-api smarttaskacr.azurecr.io/smarttask-api:v1
docker push smarttaskacr.azurecr.io/smarttask-api:v1

# Tag and push frontend image
docker build -t smarttask-ui ./smarttask-ui
docker tag smarttask-ui smarttaskacr.azurecr.io/smarttask-ui:v1
docker push smarttaskacr.azurecr.io/smarttask-ui:v1

# k8s/api-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: smarttask-api
spec:
  replicas: 2
  selector:
    matchLabels:
      app: smarttask-api
  template:
    metadata:
      labels:
        app: smarttask-api
    spec:
      containers:
        - name: api
          image: smarttaskacr.azurecr.io/smarttask-api:v1
          ports:
            - containerPort: 8080
          env:
            - name: SPRING_DATASOURCE_URL
              valueFrom:
                secretKeyRef:
                  name: smarttask-secrets
                  key: db-url
            - name: OPENAI_API_KEY
              valueFrom:
                secretKeyRef:
                  name: smarttask-secrets
                  key: openai-key

# .github/workflows/deploy.yml
name: Build and Deploy

on:
  push:
    branches: [main]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Log in to Azure
        uses: azure/login@v2
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      - name: Build and push backend image
        run: |
          az acr build --registry smarttaskacr \
            --image smarttask-api:${{ github.sha }} \
            ./smarttask-api

      - name: Deploy to AKS
        uses: azure/k8s-deploy@v4
        with:
          resource-group: smarttask-rg
          name: smarttask-aks
          manifests: k8s/
          images: smarttaskacr.azurecr.io/smarttask-api:${{ github.sha }}