EVOLUTION-NINJA

Edit File: UploadAssessment.php

<?php
namespace App\Controllers;

use App\Models\UploadAssessmentModel;
use CodeIgniter\Controller;

class UploadAssessment extends Controller {
    
    
public function upload() {
        helper(['form', 'url']);
        
  $session = session();
  $userId = $session->get('user_login_id');
  
    
    
     $fileModel = new UploadAssessmentModel();
      $db = \Config\Database::connect(); 
    $referrer_url = $this->request->getPost('referrer_url');
    
     $query = $db->table('user_course_mapping')
            ->select('faculty_ids')
            ->where('user_id',$userId)
            ->get();

$faculty = $query->getRow();
        
         
        
        // $faculty_id = $faculty ? $faculty->faculty_ids : null;
        
$faculty_ids = json_decode($faculty->faculty_ids, true);

$faculty_id = is_array($faculty_ids) && !empty($faculty_ids) ? $faculty_ids[0] : null;
        
        // print_r($faculty_id);die();

$uri = new \CodeIgniter\HTTP\URI($referrer_url);
    $chapter_id = $uri->getSegment(3);
    $mapping_id = $uri->getSegment(4); 
    
    // echo "Chapter ID: " . $chapter_id . "<br>";
    // echo "Material ID: " . $mapping_id;
    // die();

$file = $this->request->getFile('file');
        
        if ($file->isValid() && !$file->hasMoved()) {
            $newName = $file->getRandomName();
            $file->move('uploads', $newName);
            
        $session = session();
        $name = $session->get('user_username');
        
     
            $data = [
                'file_name' => $file->getClientName(),
                'file_path' => 'uploads/' . $newName,
                'student_name'=>$name,
                 'chapter_id'=>$chapter_id,
                 'mapping_id'=>$mapping_id,
                 'login_id'=> $userId,
                 'faculty_id'=>$faculty_id,
            ];

$fileModel->insert($data);
            
            return $this->response->setJSON(['status' => 'success', 'file_url' => base_url('uploads/' . $newName), 'file_name' => $file->getClientName()]);
        }

return $this->response->setJSON(['status' => 'error', 'message' => 'File upload failed.']);
    }

public function fetchFiles() {
    $session = session(); // Load session
    $userId = $session->get('user_login_id');

if (!$userId) {
        return $this->response->setJSON(['status' => 'error', 'message' => 'User not logged in']);
    }

$fileModel = new UploadAssessmentModel();

$files = $fileModel->where('login_id', $userId)->findAll();

return $this->response->setJSON(['files' => $files]);
}

// public function fetchFiles() {
//     $fileModel = new UploadAssessmentModel();

//     // Fetch files with topic details
//     $builder = $this->db->table('uploaded_files');
//     $builder->select('uploaded_files.*, topics.topic_name'); // Include only necessary columns
//     $builder->join('topics', 'uploaded_files.chapter_id = topics.topic_id', 'left'); // Use LEFT JOIN to avoid missing data

//     $query = $builder->get();
//     $files = $query->getResult(); // Fetch data

//     return $this->response->setJSON(['files' => $files]); // Return as JSON
// }

public function deleteAssessment() {
    $fileModel = new UploadAssessmentModel();
    $request = service('request');
    
    // Get the file ID from the AJAX request
    $fileId = $request->getPost('id');

if (!$fileId) {
        return $this->response->setJSON(['status' => 'error', 'message' => 'Invalid request']);
    }

$file = $fileModel->find($fileId);
    if (!$file) {
        return $this->response->setJSON(['status' => 'error', 'message' => 'File not found']);
    }

$filePath = FCPATH . $file['file_path']; // Adjust path based on your setup
    if (file_exists($filePath)) {
        unlink($filePath); 
    }

$fileModel->delete($fileId);

return $this->response->setJSON(['status' => 'success', 'message' => 'File deleted successfully']);
}

public function deleteTest() {
    $request = service('request');
    $fileId = $request->getPost('id');

if (!$fileId) {
        return $this->response->setJSON(['status' => 'error', 'message' => 'Invalid request']);
    }

$db = \Config\Database::connect();
    $builder = $db->table('test_uploads');

$file = $builder->where('id', $fileId)->get()->getRowArray();

if (!$file) {
        return $this->response->setJSON(['status' => 'error', 'message' => 'File not found']);
    }

$filePath = FCPATH . $file['file_path']; // E.g., uploads/test_files/example.pdf

if (file_exists($filePath)) {
        if (!unlink($filePath)) {
            return $this->response->setJSON(['status' => 'error', 'message' => 'Failed to delete file from disk']);
        }
    }

$builder->where('id', $fileId)->delete();

return $this->response->setJSON(['status' => 'success', 'message' => 'Test file deleted successfully']);
}

public function assessment(){
    
    
    return  view('faculty/assessment');
    
    
}

public function fetch_tests()
{
    $session = session();
    $faculty_login_id = $session->get('faculty_login_id');

$db = \Config\Database::connect(); 
    $builder = $db->table('test_uploads');

$builder->select('*');

if (!empty($faculty_login_id)) {
        $builder->where('faculty_id', $faculty_login_id);
    }

$query = $builder->get();
    $files = $query->getResult();

return $this->response->setJSON(['files' => $files]);
}

public function upload_test()
{
    $session = session();
    $faculty_login_id = $session->get('faculty_login_id');
    $file = $this->request->getFile('file');

if ($file && $file->isValid() && !$file->hasMoved()) {
        $newName = $file->getRandomName();
        $file->move('uploads/tests/', $newName);

$db = \Config\Database::connect();
        $builder = $db->table('test_uploads');

$builder->insert([
            'faculty_id' => $faculty_login_id,
            'file_name' => $newName,
            'file_path' => 'uploads/tests/' . $newName,
            'status' => 'pending'
        ]);

return $this->response->setJSON(['status' => 'success']);
    }

return $this->response->setJSON(['status' => 'error', 'message' => 'Invalid file.']);
}

public function fetch_assessments() {
    
    
       $session = session();
       
       $faculty_login_id=$session->get('faculty_login_id');
       
    //   print_r($session);die();
    $db = \Config\Database::connect(); 
    $builder = $db->table('uploaded_files');

$builder->select('uploaded_files.*, topics.topic_name, syllabus_chapter.*'); 
    $builder->join('topics', 'uploaded_files.chapter_id = topics.topic_id', 'left'); 
    $builder->join('syllabus_chapter', 'syllabus_chapter.chapter_id = topics.chapter_id', 'left');

$chapter_id = $this->request->getPost('chapter_id');
    $topic_id = $this->request->getPost('topic_id');
    
    
    
    $student_id = $this->request->getPost('student_id');
    
   if (!empty($faculty_login_id)) {
        $builder->where('uploaded_files.faculty_id', $faculty_login_id);
    }

if (!empty($chapter_id)) {
        $builder->where('syllabus_chapter.chapter_id', $chapter_id);
    }
    if (!empty($topic_id)) {
        $builder->where('topics.topic_id', $topic_id);
    }
    if (!empty($student_id)) {
        $builder->where('uploaded_files.login_id', $student_id);
    }

// Execute query
    $query = $builder->get();
    $files = $query->getResult();

// Return response in JSON format
    return $this->response->setJSON(['files' => $files]);
}

public function approveFile($fileId) {
    $fileModel = new UploadAssessmentModel();

// Check if file exists
    $file = $fileModel->find($fileId);
    if (!$file) {
        return $this->response->setJSON(['status' => 'error', 'message' => 'File not found']);
    }

// Update the status to 'approved'
    $fileModel->update($fileId, ['status' => 'approved']);

return $this->response->setJSON(['status' => 'success']);
}

// public function fetch_course(){

//     $db = \Config\Database::connect();
//     $builder = $db->table('courses'); 
//     $builder->select('course_id ,sub_domain_id,course_title'); 
//     $query = $builder->get();
//     $courses= $query->getResultArray();

//     if ($courses) {
//         return $this->response->setJSON($courses);
//     } else {
//         return $this->response->setJSON(['result' => 0, 'message' => 'No Chapter found']);
//     }
// }

public function fetch_course() {
    $db = \Config\Database::connect();
    $builder = $db->table('courses'); 
    $builder->select('course_id, sub_domain_id, course_title'); 
    $query = $builder->get();
    $courses = $query->getResultArray();

foreach ($courses as &$course) {
        // Decode sub_domain_id and get the first element
        $decoded = json_decode($course['sub_domain_id'], true);
        $course['sub_domain_id'] = is_array($decoded) && !empty($decoded) ? $decoded[0] : null;
    }

if ($courses) {
        return $this->response->setJSON($courses);
    } else {
        return $this->response->setJSON(['result' => 0, 'message' => 'No Chapter found']);
    }
}

public function fetch_Chapter($course_id = null) {
    if (!$course_id) {
        return $this->response->setJSON(['error' => 'Invalid course ID']);
    }

$db = \Config\Database::connect();
    $builder = $db->table('syllabus_chapter');
    $builder->select('chapter_id, chapter_name');
    $builder->where('sub_domain_id', $course_id);  // Filter by selected course
    $query = $builder->get();
    $Chapter = $query->getResultArray();

if (!empty($Chapter)) {
        return $this->response->setJSON($Chapter);
    } else {
        return $this->response->setJSON(['result' => 0, 'message' => 'No chapters found']);
    }
}

public function fetch_Topic($chapter_id = null) {
    if (!$chapter_id) {
        return $this->response->setJSON(['error' => 'Invalid chapter ID']);
    }

$db = \Config\Database::connect();
    $builder = $db->table('topics');
    $builder->select('topic_id, topic_name');
    $builder->where('chapter_id', $chapter_id); // Filter by selected chapter
    $query = $builder->get();
    $Topic = $query->getResultArray();

if (!empty($Topic)) {
        return $this->response->setJSON($Topic);
    } else {
        return $this->response->setJSON(['result' => 0, 'message' => 'No topics found']);
    }
}

public function fetch_Student() {
 $request = service('request');
        $term = $request->getGet('term'); // Get search term from AJAX

$db = \Config\Database::connect();
        $builder = $db->table('login'); // Use the 'login' table
        $builder->like('username', $term);
        $query = $builder->get();

$data = [];
        foreach ($query->getResult() as $row) {
            $data[] = [
                'login_id' => $row->login_id,
                'username' => $row->username
            ];
        }
        return $this->response->setJSON($data); // Return JSON response
    }

public function fetch_test_result() 
{
    $session = session();
    $faculty_login_id = $session->get('faculty_login_id');
    $chapter_id = $this->request->getPost('chapter_id');

$db = \Config\Database::connect(); 
    
    $builder = $db->table('answered_questions');
    $builder->select('login.username AS name, COUNT(answered_questions.correct_answer) AS total_marks');
    $builder->join('login', 'login.login_id = answered_questions.answered_by');
    $builder->join('questions', 'questions.qid = answered_questions.question_id');

// Use grouped where clause
    $builder->where('answered_questions.chapter_id', $chapter_id);
    $builder->where('questions.ans = answered_questions.correct_answer');

$builder->groupBy('answered_questions.answered_by');
    $query = $builder->get();
    $data = $query->getResult();

return $this->response->setJSON(['data' => $data]);   
}

}