EVOLUTION-NINJA

Edit File: LibraryController.php

<?php

namespace App\Http\Controllers;

use App\Models\add_student;
use App\Models\addBook;
use App\Models\employee;
use App\Models\issueBook;
use Illuminate\Http\Request;
use Carbon\Carbon;

class LibraryController extends Controller
{
    public function addBook(Request $request)
    {
        $validated = $request->validate([
            'title' => 'required|string',
            'author' => 'required|string',
            'category'=>'required|string',
            'book_Id' => 'required|string|unique:books,book_Id',
            'total_copies' => 'required|integer|min:1',
        ]);

$validated['available_copies'] = $validated['total_copies']; // Initialize

$book = addBook::create($validated);

return response()->json([
            'message' => 'Book added successfully',
            'data' => $book
        ]);
    }

public function getBooks()
    {
        try {
            // Fetch all books from table
            $books = addBook::all();

return response()->json([
                "success" => true,
                "data" => $books
            ], 200);
            
        } catch (\Exception $e) {
            return response()->json([
                "success" => false,
                "message" => "Failed to fetch books",
                "error" => $e->getMessage()
            ], 500);
        }
    }

public function updateBook(Request $request, $book_Id)
{
    $book = addBook::where('book_Id', $book_Id)->first();

if (!$book) {
        return response()->json(['message' => 'Book not found.'], 404);
    }

$book->update($request->only(['title', 'author','category','total_copies']));

// Optional: update available_copies if total_copies changed
    if ($request->has('total_copies')) {
        $book->available_copies = $request->input('total_copies');
        $book->save();
    }

return response()->json(['message' => 'Book updated successfully.', 'book' => $book]);
}

public function deleteBook($book_Id)
{
    $book = addBook::where('book_Id', $book_Id)->first();

if (!$book) {
        return response()->json(['message' => 'Book not found.'], 404);
    }

$book->delete();

return response()->json(['message' => 'Book deleted successfully.']);
}

public function issueBook(Request $request)
{
    $data = $request->validate([
        'user_id'   => 'required|string',
        'book_Id'   => 'required|exists:books,book_Id',
        'user_type' => 'required|in:Student,Faculty',
    ]);

// Get user based on type
    if ($data['user_type'] === 'Student') {
        $user = add_student::where('student_id', $data['user_id'])->first();
        $user_type = $user ? $user->student_name : null;
    } else {
        $user = Employee::where('employee_id', $data['user_id'])->first();
        $user_type = $user ? $user->employee_name : null;
    }

// Check user and book existence
    if (!$user) {
        return response()->json(['message' => 'User not found'], 404);
    }

$book = addBook::where('book_Id', $data['book_Id'])->first();

if (!$book) {
        return response()->json(['message' => 'Book not found'], 404);
    }

if ($book->available_copies < 1) {
        return response()->json(['message' => 'No copies available'], 400);
    }

// Decrease available copies
    $book->decrement('available_copies');

// Create issue record
    $issue = issueBook::create([
        'user_id'     => $data['user_id'],
        'user_type'   => $data['user_type'],
        'book_Id'     => $book->book_Id,
        'issue_date'  => now()->toDateString(),
        'due_date'    => now()->addDays(15)->toDateString(),
        'return_date' => null,
        'fine'        => 0,
        'status'      => 'issued',
    ]);

return response()->json([
        'message'          => 'Book issued successfully',
        'issue'            => $issue,
        'available_copies' => $book->available_copies,
        'total_copies'     => $book->total_copies
    ]);
}

public function getIssueBooks()
{
    $issues = issueBook::select('user_id', 'user_type', 'book_Id', 'issue_date', 'due_date')
        ->whereIn('status', ['issued']) // ✅ Exclude 'returned'
        ->get();

return response()->json($issues);
}

public function editIssuedBook(Request $request, $user_id)
{
    $issue = issueBook::where('user_id', $user_id)->first();

if (!$issue) {
        return response()->json(['message' => 'Issued book not found.'], 404);
    }

$validatedData = $request->validate([
        'book_Id' => 'sometimes|string|exists:books,book_Id',
    ]);

// If book_Id is being changed, manage available copies
    if (isset($validatedData['book_Id']) && $validatedData['book_Id'] != $issue->book_Id) {
        $oldBook = addBook::where('book_Id', $issue->book_Id)->first();
        $newBook = addBook::where('book_Id', $validatedData['book_Id'])->first();

// Ensure the new book exists and has available copies
        if (!$newBook) {
            return response()->json(['message' => 'The selected book does not exist.'], 404);
        }

if ($newBook->available_copies === null || $newBook->available_copies < 1) {
            return response()->json(['message' => 'The selected book is not available for issue.'], 400);
        }

// Update copies
        if ($oldBook) {
            $oldBook->available_copies += 1;
            $oldBook->save();
        }

$newBook->available_copies -= 1;
        $newBook->save();

// Update issued book record
        $issue->book_Id = $validatedData['book_Id'];
        $issue->save();
    }

return response()->json([
        'message' => 'Issued book record updated successfully.',
        'data' => $issue
    ]);
}

public function deleteIssuedBook($book_Id)
{
    $issue = issueBook::where('book_Id', $book_Id)->first();

if (!$issue) {
        return response()->json(['message' => 'Issued book not found.'], 404);
    }

$issue->delete();

return response()->json(['message' => 'Issued book record deleted successfully.']);
}

// public function returnBook(Request $request)
// {
//     $user_id   = $request->input('user_id');
//     $book_Id   = $request->input('book_Id');
//     $fine_paid = $request->input('fine_paid', false); // This should be true/false from frontend

//     // Find the issued book entry
//     $issue = issueBook::where('user_id', $user_id)
//         ->where('book_Id', $book_Id)
//         ->whereIn('status', ['issued', 'overdue'])
//         ->first();

//     if (!$issue) {
//         return response()->json(['message' => 'No matching issued book found.'], 404);
//     }

//     $today     = now()->toDateString();
//     $due_date  = $issue->due_date;
//     $isOverdue = strtotime($today) > strtotime($due_date);

//     if ($isOverdue) {
//         // Book is overdue
//         if ($fine_paid) {
//             // Fine has been paid; allow return
//             $issue->return_date = $today;
//             $issue->fine        = 0;
//             $issue->status      = 'returned';
//         } else {
//             // Fine unpaid; mark as overdue
//             $issue->fine   = 50;
//             $issue->status = 'overdue';
//             $issue->save();

//             return response()->json([
//                 'message' => 'Book is overdue. Please pay fine to return.',
//                 'fine'    => $issue->fine,
//                 'status'  => $issue->status
//             ]);
//          }
//     } else {
//         // Not overdue; normal return
//         $issue->return_date = $today;
//         $issue->fine        = 0;
//         $issue->status      = 'returned';
//     }

//     $issue->save();

//     return response()->json([
//         'success' => true,
//         'message' => 'Book returned successfully.',
//         'data'    => $issue
//     ]);
// }

public function returnBook(Request $request)
{
    $user_id = $request->input('user_id');
    $book_Id = $request->input('book_Id');

$issue = issueBook::where('user_id', $user_id)
        ->where('book_Id', $book_Id)
        ->whereIn('status', ['issued', 'overdue'])
        ->first();

if (!$issue) {
        return response()->json(['message' => 'No matching issued book found.'], 404);
    }

$today     = now()->toDateString();
    $due_date  = $issue->due_date;
    $return_date = $today;

// ✅ Calculate fine (₹1 per day late)
    $fine = 0;
    if (strtotime($return_date) > strtotime($due_date)) {
        $diffDays = (strtotime($return_date) - strtotime($due_date)) / 86400;
        $fine = (int) $diffDays;
    }

$issue->return_date = $return_date;
    $issue->fine        = $fine;
   $issue->status = 'returned'; // Always returned once book is given back
    $issue->save();

return response()->json([
        'success' => true,
        'message' => 'Book returned successfully.',
        'data'    => $issue
    ]);
}

public function getReports()
{
    $reports = issueBook::select(
        'user_id',
        'user_type',
        'book_Id',
        'issue_date',
        'due_date',
        'return_date',
        'fine',
        'status'
    )->get();

$today = now()->toDateString();

$reports->transform(function ($r) use ($today) {
        // Case 1: Book not returned yet
        if (!$r->return_date) {
            if (strtotime($today) > strtotime($r->due_date)) {
                // overdue
                $diffDays = Carbon::parse($r->due_date)->diffInDays($today, false);
                $r->status = 'overdue';
                $r->fine = max(0, $diffDays);
            } else {
                // still issued and within due date
                $r->status = 'issued';
                $r->fine = 0;
            }
        }
        // Case 2: Book returned
        else {
            // fine already stored in DB (either 0 or >0)
            $r->status = 'returned';
        }

return $r;
    });

return response()->json($reports);
}

//to get book_id in return
public function getIssuedBooks($user_id)
{
    $today = now()->toDateString();

// Fetch books that are not returned
    $issuedBooks = issueBook::where('user_id', $user_id)
        ->whereIn('status', ['issued', 'overdue'])
        ->get();

if ($issuedBooks->isEmpty()) {
        return response()->json([
            'message' => 'No issued books found.',
            'issuedBooks' => []
        ], 404);
    }

// Update overdue status and calculate fine
    foreach ($issuedBooks as $book) {
      if ($book->status === 'issued' && $book->due_date < $today) {
    // Book is overdue
    $daysLate = Carbon::parse($book->due_date)->diffInDays($today, false); // false → signed diff
    $book->status = 'overdue';
    $book->fine = max(0, $daysLate); // ₹1 per day
    $book->save();

} else {
            // Not overdue, no fine
            $book->fine = 0;
            $book->save();
        }
    }

return response()->json([
        'message' => 'Issued books fetched successfully.',
        'issuedBooks' => $issuedBooks
    ]);
}

}
?>