Gecko [ school.pilasatech.net ]

Name	Size	Permission	Date
AttendanceResource	[ DIR ]	drwxrwxrwx	2025-03-23 13:10
CourseAssignmentResource	[ DIR ]	drwxrwxrwx	2025-03-23 13:10
CourseEnrollmentResource	[ DIR ]	drwxrwxrwx	2025-03-23 13:10
GradeResource	[ DIR ]	drwxrwxrwx	2025-03-23 13:10
MarkResource	[ DIR ]	drwxrwxrwx	2025-03-23 13:10
MessageResource	[ DIR ]	drwxr-xr-x	2025-03-27 22:56
PromotionResource	[ DIR ]	drwxrwxrwx	2025-03-24 00:50
ReportResource	[ DIR ]	drwxrwxrwx	2025-03-24 10:11
StudentResource	[ DIR ]	drwxrwxrwx	2025-03-23 13:10
SubjectResource	[ DIR ]	drwxrwxrwx	2025-03-23 13:10
TeacherResource	[ DIR ]	drwxrwxrwx	2025-03-23 13:10
UserResource	[ DIR ]	drwxrwxrwx	2025-03-23 13:10
Widgets	[ DIR ]	drwxrwxrwx	2025-03-23 19:51
AttendanceResource.php	13.87 KB	-rw-rw-rw-	2025-03-24 07:12
CourseAssignmentResource.php	7.36 KB	-rw-rw-rw-	2025-03-27 22:46
CourseEnrollmentResource.php	15.35 KB	-rw-rw-rw-	2025-03-24 06:07
GradeResource.php	3.48 KB	-rw-rw-rw-	2025-03-24 06:33
MarkResource.php	17.63 KB	-rw-rw-rw-	2025-03-28 00:00
MessageResource.php	5.43 KB	-rw-r--r--	2025-03-28 00:04
PromotionResource.php	8.05 KB	-rw-rw-rw-	2025-03-24 03:04
StudentResource.php	5.58 KB	-rw-rw-rw-	2025-03-27 22:49
SubjectResource.php	2.81 KB	-rw-rw-rw-	2025-03-24 11:32
TeacherResource.php	3.92 KB	-rw-rw-rw-	2025-03-24 11:32
UserResource.php	4.91 KB	-rw-rw-rw-	2025-03-24 06:45

Rename

<?php

namespace App\Filament\Resources;

use App\Filament\Resources\MarkResource\Pages;
use App\Filament\Resources\MarkResource\RelationManagers;
use App\Models\Mark;
use App\Models\CourseEnrollment;
use App\Models\User;
use App\Models\Message;
use Filament\Facades\Filament;
use Filament\Forms;
use Filament\Forms\Form;
use Filament\Resources\Resource;
use Filament\Tables;
use Filament\Tables\Table;
use Filament\Notifications\Notification;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\Auth;

class MarkResource extends Resource
{
    protected static ?string $model = Mark::class;

protected static ?string $navigationIcon = 'heroicon-o-rectangle-stack';
    protected static ?string $navigationGroup = 'Result Assessment';

public static function form(Form $form): Form
    {
        return $form
            ->schema([
                Forms\Components\Section::make('Mark Details')
                    ->schema([
                        Forms\Components\Select::make('grade_id')
                            ->label('Grade')
                            ->relationship('grade', 'name', function ($query) {
                                $user = Auth::user();
                                if ($user->hasRole('teacher')) {
                                    $gradeIds = $user->assignments->pluck('grade_id');
                                    return $query->whereIn('id', $gradeIds);
                                }
                                return $query;
                            })
                            ->required()
                            ->searchable()
                            ->preload()
                            ->reactive()
                            ->afterStateUpdated(function (callable $set) {
                                $set('enrollment_id', null);
                            }),
                        Forms\Components\Select::make('enrollment_id')
                            ->label('Student Enrollment')
                            ->relationship('enrollment', 'id', function ($query, callable $get) {
                                $user = Auth::user();
                                $gradeId = $get('grade_id');
                                if ($user->hasRole('teacher')) {
                                    $query->whereIn('course_id', $user->assignments->pluck('course_id'))
                                        ->whereIn('year', $user->assignments->pluck('year'))
                                        ->whereIn('semester', $user->assignments->pluck('semester'));
                                }
                                if ($gradeId) {
                                    $query->whereHas('student', fn ($q) => $q->where('grade_id', $gradeId));
                                }
                                return $query;
                            })
                            ->getOptionLabelFromRecordUsing(fn ($record) => "{$record->student->name} - {$record->course->name}")
                            ->required()
                            ->searchable()
                            ->preload()
                            ->optionsLimit(50),
                        Forms\Components\Hidden::make('teacher_id')
                            ->default(fn () => Auth::id())
                            ->dehydrated(true),
                        Forms\Components\TextInput::make('score')
                            ->numeric()
                            ->required()
                            ->minValue(0)
                            ->maxValue(function (callable $get) {
                                $maxScore = $get('max_score');
                                return $maxScore ?: 100;
                            })
                            ->label('Score')
                            ->placeholder('Enter earned score')
                            ->reactive(),
                            // ->rule('lte:max_score'),
                        Forms\Components\TextInput::make('max_score')
                            ->numeric()
                            ->required()
                            ->minValue(1)
                            ->label('Max Score')
                            ->placeholder('Enter maximum possible score')
                            ->helperText('The maximum score for this assessment.')
                            ->reactive(),
                        Forms\Components\Textarea::make('remark')
                            ->label('Remark')
                            ->rows(3)
                            ->nullable()
                            ->placeholder('Optional comments about this mark'),
                    ])
                    ->columns(2),
            ]);
    }

public static function table(Table $table): Table
    {
        return $table
            ->query(function () {
                $user = Auth::user();
                if ($user->hasRole('teacher')) {
                    return Mark::where('teacher_id', $user->id)
                            ->whereIn('enrollment_id', function ($query) use ($user) {
                                $query->select('id')
                                    ->from('course_enrollments')
                                    ->whereIn('course_id', $user->assignments->pluck('course_id'))
                                    ->where(function ($query) use ($user) {
                                        foreach ($user->assignments as $assignment) {
                                            $query->orWhere(function ($q) use ($assignment) {
                                                $q->where('course_id', $assignment->course_id)
                                                ->where('year', $assignment->year)
                                                ->where('semester', $assignment->semester);
                                            });
                                        }
                                    });
                            });
                        // ->whereIn('enrollment_id', CourseEnrollment::whereIn('course_id', $user->assignments->pluck('course_id'))
                        //     ->where('year', $user->assignments->pluck('year'))
                        //     ->where('semester', $user->assignments->pluck('semester'))
                        //     ->pluck('id'));
                }
                if ($user->hasRole('student')) {
                    return Mark::whereIn('enrollment_id', CourseEnrollment::whereIn('student_id', $user->enrollments->pluck('student_id'))
                            ->pluck('id'));
                }
                return Mark::query();
            })
            ->columns([
                Tables\Columns\TextColumn::make('enrollment.student.name')
                    ->label('Student')
                    ->sortable()
                    ->searchable(),
                Tables\Columns\TextColumn::make('grade.name')
                    ->label('Grade')
                    ->sortable()
                    ->searchable(),
                Tables\Columns\TextColumn::make('enrollment.course.name')
                    ->label('Course')
                    ->sortable()
                    ->searchable(),
                Tables\Columns\TextColumn::make('score')
                    ->label('Score')
                    ->getStateUsing(fn ($record) => "{$record->score} out of {$record->max_score}")
                    ->sortable(['score']),
                Tables\Columns\TextColumn::make('remark')
                    ->limit(50)
                    ->tooltip(fn ($state) => $state),
                Tables\Columns\TextColumn::make('teacher.name')
                    ->label('Assigned By')
                    ->sortable()
                    ->visible(fn () => Auth::user()->hasRole('admin')),
                Tables\Columns\TextColumn::make('created_at')
                    ->dateTime()
                    ->sortable()
                    ->toggleable(isToggledHiddenByDefault: true),
            ])
            ->filters([
                Tables\Filters\SelectFilter::make('grade')
                    ->relationship('grade', 'name')
                    ->label('Filter by Grade')
                    ->preload()
                    ->searchable()
                    ->visible(fn () => Auth::user()->hasRole('teacher')),
                Tables\Filters\SelectFilter::make('course')
                    ->relationship('enrollment.course', 'name')
                    ->label('Filter by Course')
                    ->preload()
                    ->searchable()
                    ->visible(fn () => Auth::user()->hasRole('teacher')),
                Tables\Filters\SelectFilter::make('student')
                    ->relationship('enrollment.student', 'name')
                    ->label('Filter by Student')
                    ->preload()
                    ->searchable()
                    ->visible(fn () => Auth::user()->hasRole('teacher')),
            ])
            ->actions([
                // Tables\Actions\ViewAction::make()
                //     ->url(fn ($record) => static::getUrl('view', ['student_id' => $record->enrollment->student_id])),
                // Update the ViewAction in the table method
                Tables\Actions\Action::make('sendTotalMarks')
                    ->label('Send Total Marks')
                    ->icon('heroicon-o-paper-airplane')
                    ->form([
                        Forms\Components\Select::make('grade_id')
                            ->label('Grade')
                            ->options(fn () => Auth::user()->assignments->pluck('grade.name', 'grade_id'))
                            ->required()
                            ->reactive()
                            ->afterStateUpdated(fn (callable $set) => $set('subject_id', null) && $set('student_id', null)),
                        Forms\Components\Select::make('subject_id')
                            ->label('Subject')
                            ->options(function (callable $get) {
                                $gradeId = $get('grade_id');
                                $teacher = Auth::user();
                                if (!$gradeId) return [];
                                return $teacher->assignments
                                    ->where('grade_id', $gradeId)
                                    ->pluck('course.name', 'course_id')
                                    ->all();
                            })
                            ->required()
                            ->reactive()
                            ->afterStateUpdated(fn (callable $set) => $set('student_id', null)),
                        Forms\Components\Select::make('student_id')
                            ->label('Student')
                            ->options(function (callable $get) {
                                $teacher = Auth::user();
                                $gradeId = $get('grade_id');
                                $subjectId = $get('subject_id');

if (!$gradeId || !$subjectId) return [];

// Fetch students with marks for the selected grade and subject
                                return Mark::whereHas('enrollment', function ($query) use ($subjectId, $gradeId) {
                                    $query->where('course_id', $subjectId)
                                          ->whereHas('student', fn ($q) => $q->where('grade_id', $gradeId));
                                })
                                ->with('enrollment.student')
                                ->get()
                                ->pluck('enrollment.student.name', 'enrollment.student_id')
                                ->all();
                            })
                            ->required()
                            ->multiple()
                            ->reactive(),
                        Forms\Components\Textarea::make('remark')
                            ->label('Remark')
                            ->nullable(),
                    ])
                    ->action(function (array $data) {
                        $teacher = Auth::user();
                        $gradeId = $data['grade_id'];
                        $subjectId = $data['subject_id'];
                        $studentIds = $data['student_id'];
                        $remark = $data['remark'];

foreach ($studentIds as $studentId) {
                            $totalMarks = Mark::whereHas('enrollment', fn ($q) => $q->where('student_id', $studentId)->where('course_id', $subjectId))->sum('score');
                            $maxMarks = Mark::whereHas('enrollment', fn ($q) => $q->where('student_id', $studentId)->where('course_id', $subjectId))->sum('max_score');
                            // $totalMark = $maxMarks > 0 ? number_format(($totalMarks / $maxMarks) * 100, 2) : 'N/A';
                            $totalMark = number_format($totalMarks, 2).' / '. number_format($maxMarks, 2);

Message::create([
                                // 'grade_id' => $teacher->assignments->where('course_id', $subjectId)->first()->grade_id ?? null,
                                'grade_id' => $gradeId,
                                'subject_id' => $subjectId,
                                'teacher_id' => $teacher->id,
                                'student_id' => $studentId,
                                'mark' => $totalMark,
                                'remark' => $remark,
                            ]);
                        }

Notification::make()->title('Marks Sent')->success()->send();
                    })
                    ->visible(fn () => Auth::user()->hasRole('teacher')),Tables\Actions\ViewAction::make()
                    ->url(fn ($record) => MarkResource::getUrl('view', [])),
                Tables\Actions\EditAction::make(),
                Tables\Actions\DeleteAction::make(),
            ])
            ->bulkActions([
                Tables\Actions\BulkActionGroup::make([
                    Tables\Actions\DeleteBulkAction::make(),
                ]),
            ])
            ->defaultSort('created_at', 'desc');
    }

public static function getRelations(): array
    {
        return [];
    }

public static function getPages(): array
    {
        return [
            'index' => Pages\ListMarks::route('/'),
            'create' => Pages\CreateMark::route('/create'),
            'edit' => Pages\EditMark::route('/{record}/edit'),
            // 'view' => Pages\ViewStudentMarks::route('/view/{student_id}'),
            'view' => Pages\ViewStudentMarks::route('/view'), // Updated route
            'view-student-marks' => Pages\ViewStudentMarks::route('/view-student-marks'),
        ];
    }

public static function canViewAny(): bool
    {
        // Allow both teachers and admins to view marks
        return Auth::user()->hasAnyRole(['teacher', 'admin']);
    }

public static function canCreate(): bool
    {
        // Allow both teachers and admins to create marks
        return Auth::user()->hasAnyRole(['teacher', 'admin']);
    }

public static function canEdit($record): bool
    {
        $user = Auth::user();
        // Allow admins to edit any record
        // Allow teachers to edit only their own records
        return $user->hasRole('admin') ||
               ($user->hasRole('teacher') && $record->teacher_id === $user->id);
    }

public static function canDelete($record): bool
    {
        $user = Auth::user();
        return $user->hasRole('admin') ||
               ($user->hasRole('teacher') && $record->teacher_id === $user->id);
    }

public static function getNavigationBadge(): ?string
    {
        $user = Auth::user();
        if ($user->hasRole('teacher')) {
            return (string) Mark::where('teacher_id', $user->id)->count();
        }
        return (string) Mark::count();
    }

public static function getNavigationItems(): array
    {
        $user = Auth::user();
        $marksCount = 0;
        if ($user->hasRole('teacher')) {
            $marksCount = Mark::where('teacher_id', $user->id)->count();
        }
        if ($user->hasRole('student')) {
            $marksCount = Mark::whereHas('enrollment', function ($query) use ($user) {
                $query->whereHas('student', function ($query) use ($user) {
                    $query->where('id',  $user->id);
                });
            })
            ->with('enrollment.student')
            ->get()->count();
        }
        if ($user->hasRole('admin')) {
            $marksCount = Mark::count();
        }

return [
            \Filament\Navigation\NavigationItem::make('Marks')
                ->url(fn () => static::getUrl('index'))
                ->icon('heroicon-o-eye')
                ->group('Result Assessment')
                ->isActiveWhen(fn () => request()->routeIs('filament.admin.resources.marks.index'))
                ->visible(fn () => Auth::user()->hasAnyRole(['teacher', 'admin']))
                ->badge($marksCount),

\Filament\Navigation\NavigationItem::make('My Marks')
                ->url(fn () => static::getUrl('view-student-marks'))
                ->icon('heroicon-o-eye')
                ->group('Result Assessment')
                ->isActiveWhen(fn () => request()->routeIs('filament.admin.resources.marks.view-student-marks'))
                ->visible(fn () => Auth::user()->hasAnyRole(['student']))
                ->badge($marksCount),
        ];
    }
}