ILIAS\Test\Participants\ParticipantTable Class Reference

Inheritance diagram for ILIAS\Test\Participants\ParticipantTable:

Collaboration diagram for ILIAS\Test\Participants\ParticipantTable:

Public Member Functions
	__construct (private readonly UIFactory $ui_factory, private readonly \ilUIService $ui_service, private readonly Language $lng, private readonly \ilTestAccess $test_access, private readonly RequestDataCollector $test_request, private readonly \ilTestParticipantAccessFilterFactory $participant_access_filter, private readonly ParticipantRepository $repository, private readonly ResultsDataFactory $results_data_factory, private readonly ResultsPresentationSettings $results_presentation_settings, private readonly \ilObjUser $current_user, private readonly \ilObjTest $test_object, private readonly ParticipantTableActions $table_actions)
	execute (URLBuilder $url_builder)
	getComponents (URLBuilder $url_builder, string $filter_url)
	getTotalRowCount (mixed $additional_viewcontrol_data, mixed $filter_data, mixed $additional_parameters)
	Mainly for the purpose of pagination-support, it is important to know about the total number of records available. More...
Public Member Functions inherited from ILIAS\UI\Component\Table\DataRetrieval
	getRows (DataRowBuilder $row_builder, array $visible_column_ids, Range $range, Order $order, mixed $additional_viewcontrol_data, mixed $filter_data, mixed $additional_parameters)
	This is called by the table to retrieve rows; map data-records to rows using the $row_builder e.g. More...
	getTotalRowCount (mixed $additional_viewcontrol_data, mixed $filter_data, mixed $additional_parameters)
	Mainly for the purpose of pagination-support, it is important to know about the total number of records available. More...

Private Member Functions
	acquireParameters ($url_builder)
	getPostLoadFilters ()
	getPostLoadOrderFields ()
	getFilterComponent (string $action, ServerRequestInterface $request)
	getFilterFields (FieldFactory $field_factory)
	getTableComponent (ServerRequestInterface $request, ?array $filter)
	getColumns ()
	loadRecords (?array $filter, Order $order)
	buildAccessFilteredParticipantsList (array $records)
	getViewControlledRecords (?array $filter_data, Range $range, Order $order)
	filterRecords (iterable $records, ?array $filter_data)
	matchFilter (Participant $record, ?array $filter)
	orderRecords (iterable $records, Order $order)
	limitRecords (array $records, Range $range)

Private Attributes
const	ID = 'pt'
iterable	$records = null
bool	$scoring_enabled = false

Detailed Description

Definition at line 39 of file ParticipantTable.php.

Constructor & Destructor Documentation

__construct()

ILIAS\Test\Participants\ParticipantTable::__construct	(	private readonly UIFactory	$ui_factory,
		private readonly \ilUIService	$ui_service,
		private readonly Language	$lng,
		private readonly \ilTestAccess	$test_access,
		private readonly RequestDataCollector	$test_request,
		private readonly \ilTestParticipantAccessFilterFactory	$participant_access_filter,
		private readonly ParticipantRepository	$repository,
		private readonly ResultsDataFactory	$results_data_factory,
		private readonly ResultsPresentationSettings	$results_presentation_settings,
		private readonly \ilObjUser	$current_user,
		private readonly \ilObjTest	$test_object,
		private readonly ParticipantTableActions	$table_actions
	)

Definition at line 45 of file ParticipantTable.php.

      {
        $this->scoring_enabled = $this->test_object->getGlobalSettings()->isManualScoringEnabled();
    }

Member Function Documentation

acquireParameters()

ILIAS\Test\Participants\ParticipantTable::acquireParameters (   $url_builder )

private

Definition at line 172 of file ParticipantTable.php.

                                                    : array
    {
        return $url_builder->acquireParameters(
            [self::ID],
            ParticipantTableActions::ROW_ID_PARAMETER,
            ParticipantTableActions::ACTION_PARAMETER,
            ParticipantTableActions::ACTION_TYPE_PARAMETER
        );
    }

Referenced by ILIAS\Test\Participants\ParticipantTable\execute().

Here is the caller graph for this function:

buildAccessFilteredParticipantsList()

ILIAS\Test\Participants\ParticipantTable::buildAccessFilteredParticipantsList ( array  $records )

private

Parameters

array<Participant>

$records

Returns

array<int>

Definition at line 500 of file ParticipantTable.php.

                                                                        : array
    {
        $manage_access_filter = $this->participant_access_filter
            ->getManageParticipantsUserFilter($this->test_object->getRefId());
        $access_results_access_filter = $this->participant_access_filter
            ->getAccessResultsUserFilter($this->test_object->getRefId());
        $participant_ids = array_map(
            fn(Participant $participant) => $participant->getUserId(),
            $records
        );
        return $manage_access_filter($participant_ids) + $access_results_access_filter($participant_ids);
    }

References ILIAS\Test\Participants\Participant\getUserId().

Here is the call graph for this function:

execute()

ILIAS\Test\Participants\ParticipantTable::execute

(

URLBuilder

$url_builder

)

Definition at line 62 of file ParticipantTable.php.

                                                    : ?Modal
    {
        return $this->table_actions->execute(...$this->acquireParameters($url_builder));
    }

References ILIAS\Test\Participants\ParticipantTable\acquireParameters().

Here is the call graph for this function:

filterRecords()

ILIAS\Test\Participants\ParticipantTable::filterRecords ( iterable  $records, ?array  $filter_data  )

private

Definition at line 535 of file ParticipantTable.php.

                                                                          : iterable
    {
        foreach ($records as $record) {
            if ($this->matchFilter($record, $filter_data)) {
                yield $record;
            }
        }
    }

getColumns()

ILIAS\Test\Participants\ParticipantTable::getColumns ( )

private

Returns

array<string, Column>

Definition at line 363 of file ParticipantTable.php.

                                 : array
    {
        $column_factory = $this->ui_factory->table()->column();
 
        $columns = [
            'name' => $column_factory->text($this->lng->txt('name'))
                ->withIsSortable(!$this->test_object->getAnonymity())
        ];
        if (!$this->test_object->getAnonymity()) {
            $columns['login'] = $column_factory->text($this->lng->txt('login'))->withIsSortable(true);
        }
 
        $columns += [
            'matriculation' => $column_factory->text($this->lng->txt('matriculation'))
                ->withIsOptional(true, false)
                ->withIsSortable(true),
            'ip_range' => $column_factory->text($this->lng->txt('client_ip_range'))
                ->withIsOptional(true, false)
                ->withIsSortable(true),
            'attempt_started_at' => $column_factory->date(
                $this->lng->txt('tst_attempt_started'),
                $this->current_user->getDateTimeFormat()
            )->withIsSortable(true),
            'total_time_on_task' => $column_factory->text($this->lng->txt('working_time'))
                ->withIsOptional(true, false),
            'total_attempts' => $column_factory->number($this->lng->txt('total_attempts'))
                ->withIsOptional(true, false)
                ->withIsSortable(true),
        ];
 
        $columns['status_of_attempt'] = $column_factory->text($this->lng->txt('status_of_attempt'))
           ->withIsSortable(true);
 
        if ($this->test_object->getEnableProcessingTime()) {
            $columns['remaining_duration'] = $column_factory->text($this->lng->txt('remaining_duration'))
                ->withIsOptional(true);
            $columns['total_duration'] = $column_factory->text($this->lng->txt('total_duration'))
                ->withIsOptional(true, false);
            $columns['extra_time'] = $column_factory->text($this->lng->txt('extratime'))
                ->withIsOptional(true, false);
        }
 
        if ($this->test_object->getMainSettings()->getTestBehaviourSettings()->getExamIdInTestAttemptEnabled()) {
            $columns['id_of_attempt'] = $column_factory->text($this->lng->txt('exam_id_of_attempt'))
                ->withIsOptional(true, false)
                ->withIsSortable(true);
        }
 
        if ($this->test_access->checkParticipantsResultsAccess()) {
            $columns['reached_points'] = $column_factory->text($this->lng->txt('tst_reached_points'))
                ->withIsSortable(true)
                ->withOrderingLabels(...$column_factory->number($this->lng->txt('tst_reached_points'))->getOrderingLabels());
            $columns['nr_of_answered_questions'] = $column_factory->text($this->lng->txt('tst_answered_questions'))
                ->withIsOptional(true, false)
                ->withIsSortable(true)
                ->withOrderingLabels(...$column_factory->number($this->lng->txt('tst_answered_questions'))->getOrderingLabels());
            $columns['percent_of_available_points'] = $column_factory->number($this->lng->txt('tst_percent_solved'))
                ->withUnit('%')
                ->withIsOptional(true, false)
                ->withIsSortable(true);
            $columns['test_passed'] = $column_factory->boolean(
                $this->lng->txt('tst_passed'),
                $this->ui_factory->symbol()->icon()->custom(
                    'assets/images/standard/icon_checked.svg',
                    $this->lng->txt('yes'),
                    'small'
                ),
                $this->ui_factory->symbol()->icon()->custom(
                    'assets/images/standard/icon_unchecked.svg',
                    $this->lng->txt('no'),
                    'small'
                )
            )->withIsSortable(true)
            ->withOrderingLabels(
                "{$this->lng->txt('tst_passed')}, {$this->lng->txt('no')} {$this->lng->txt('order_option_first')}",
                "{$this->lng->txt('tst_passed')}, {$this->lng->txt('yes')} {$this->lng->txt('order_option_first')}"
            );
            $columns['mark'] = $column_factory->text($this->lng->txt('tst_mark'))
                ->withIsOptional(true, false)
                ->withIsSortable(true);
        }
        if ($this->scoring_enabled) {
            $columns['scoring_finalized'] = $column_factory->boolean(
                $this->lng->txt('finalized_evaluation'),
                $this->ui_factory->symbol()->icon()->custom(
                    'assets/images/standard/icon_checked.svg',
                    $this->lng->txt('yes'),
                    'small'
                ),
                $this->ui_factory->symbol()->icon()->custom(
                    'assets/images/standard/icon_unchecked.svg',
                    $this->lng->txt('no'),
                    'small'
                )
            )->withIsOptional(true, false)
            ->withIsSortable(true);
        }
 
        $columns['last_access'] = $column_factory->date(
            $this->lng->txt('last_access'),
            $this->current_user->getDateTimeFormat()
        );
 
        return $columns;
    }

References ILIAS\Repository\lng().

Here is the call graph for this function:

getComponents()

ILIAS\Test\Participants\ParticipantTable::getComponents	(	URLBuilder	$url_builder,
		string	$filter_url
	)

Returns

array<Component>

Definition at line 70 of file ParticipantTable.php.

                                                                              : array
    {
        $filter = $this->getFilterComponent($filter_url, $this->test_request->getRequest());
        $table = $this->getTableComponent(
            $this->test_request->getRequest(),
            $this->ui_service->filter()->getData($filter)
        );
 
        return [
            $filter,
            $table->withActions($this->table_actions->getEnabledActions(...$this->acquireParameters($url_builder)))
        ];
    }

References ILIAS\Test\Participants\ParticipantTable\getFilterComponent(), and ILIAS\Test\Participants\ParticipantTable\getTableComponent().

Here is the call graph for this function:

getFilterComponent()

ILIAS\Test\Participants\ParticipantTable::getFilterComponent ( string  $action, ServerRequestInterface  $request  )

private

Definition at line 268 of file ParticipantTable.php.

                                                                                        : FilterComponent
    {
        $filter_inputs = [];
        $is_input_initially_rendered = [];
        $field_factory = $this->ui_factory->input()->field();
 
        foreach ($this->getFilterFields($field_factory) as $filter_id => $filter) {
            [$filter_inputs[$filter_id], $is_input_initially_rendered[$filter_id]] = $filter;
        }
 
        return $this->ui_service->filter()->standard(
            "participant_filter_{$this->test_request->getRefId()}",
            $action,
            $filter_inputs,
            $is_input_initially_rendered,
            true,
            true
        );
    }

Referenced by ILIAS\Test\Participants\ParticipantTable\getComponents().

Here is the caller graph for this function:

getFilterFields()

ILIAS\Test\Participants\ParticipantTable::getFilterFields ( FieldFactory  $field_factory )

private

Parameters

FieldFactory

$field_factory

Returns

array<string, FilterInput>

Definition at line 293 of file ParticipantTable.php.

                                                                 : array
    {
        $yes_no_all_options = [
            'true' => $this->lng->txt('yes'),
            'false' => $this->lng->txt('no')
        ];
 
        $solution_options = [
            'false' => $this->lng->txt('without_solution'),
            'true' => $this->lng->txt('with_solution')
        ];
 
        $status_of_attempt_options = [
            StatusOfAttempt::NOT_YET_STARTED->value => $this->lng->txt(StatusOfAttempt::NOT_YET_STARTED->value),
            StatusOfAttempt::RUNNING->value => $this->lng->txt(StatusOfAttempt::RUNNING->value),
            StatusOfAttempt::FINISHED_BY_UNKNOWN->value => $this->lng->txt(StatusOfAttempt::FINISHED_BY_UNKNOWN->value),
            StatusOfAttempt::FINISHED_BY_ADMINISTRATOR->value => $this->lng->txt(StatusOfAttempt::FINISHED_BY_ADMINISTRATOR->value),
            StatusOfAttempt::FINISHED_BY_CRONJOB->value => $this->lng->txt(StatusOfAttempt::FINISHED_BY_CRONJOB->value),
            StatusOfAttempt::FINISHED_BY_DURATION->value => $this->lng->txt(StatusOfAttempt::FINISHED_BY_DURATION->value),
            StatusOfAttempt::FINISHED_BY_PARTICIPANT->value => $this->lng->txt(StatusOfAttempt::FINISHED_BY_PARTICIPANT->value),
        ];
 
        $filters = [
            'name' => [$field_factory->text($this->lng->txt('name')), true],
            'login' => [$field_factory->text($this->lng->txt('login')), true],
            'ip_range' => [$field_factory->text($this->lng->txt('client_ip_range')), true],
            'solution' => [$field_factory->select($this->lng->txt('solutions'), $solution_options), true],
        ];
 
        if ($this->test_object->getEnableProcessingTime()) {
            $filters['extra_time'] = [$field_factory->select($this->lng->txt('extratime'), $yes_no_all_options), true];
        }
 
        $filters['status_of_attempt'] = [
            $field_factory->select($this->lng->txt('status_of_attempt'), $status_of_attempt_options),
            true
        ];
 
        $filters['test_passed'] = [
            $field_factory->select($this->lng->txt('tst_passed'), $yes_no_all_options),
            true
        ];
 
        if ($this->scoring_enabled) {
            $filters['scoring_finalized'] = [
                $field_factory->select($this->lng->txt('finalized_evaluation'), $yes_no_all_options),
                true
            ];
        }
 
        return $filters;
    }

References ILIAS\Repository\lng(), and true.

Here is the call graph for this function:

getPostLoadFilters()

ILIAS\Test\Participants\ParticipantTable::getPostLoadFilters ( )

private

Returns

array<string, \Closure>

Definition at line 185 of file ParticipantTable.php.

                                         : array
    {
        return [
            'solution' => fn(string $value, Participant $record) =>
                $value === 'true' ? $record->hasAnsweredQuestionsForScoredAttempt() : !$record->hasAnsweredQuestionsForScoredAttempt(),
            'status_of_attempt' => fn(string $value, Participant $record) =>
                ($value === StatusOfAttempt::NOT_YET_STARTED->value && $record->getAttemptOverviewInformation()?->getStatusOfAttempt() === null) ||
                $value === $record->getAttemptOverviewInformation()?->getStatusOfAttempt()->value,
            'test_passed' => fn(string $value, Participant $record) => $value === 'true'
                ? $record->getAttemptOverviewInformation()?->hasPassingMark() === true
                : $record->getAttemptOverviewInformation()?->hasPassingMark() !== true,
            'scoring_finalized' => fn(string $value, Participant $record) => $value === 'true'
                ? $record->isScoringFinalized() == true
                : $record->isScoringFinalized() === false
        ];
    }

References ILIAS\Test\Participants\Participant\getAttemptOverviewInformation(), ILIAS\Test\Participants\Participant\hasAnsweredQuestionsForScoredAttempt(), ILIAS\Test\Participants\Participant\isScoringFinalized(), and true.

Here is the call graph for this function:

getPostLoadOrderFields()

ILIAS\Test\Participants\ParticipantTable::getPostLoadOrderFields ( )

private

Returns

array<string, \Closure>

Definition at line 205 of file ParticipantTable.php.

                                             : array
    {
        $processing_time = $this->test_object->getProcessingTimeInSeconds();
        $reset_time_on_new_attempt = $this->test_object->getResetProcessingTime();
 
        return [
            'attempt_started_at' => static fn(Participant $a, Participant $b) => $a->getFirstAccess() <=> $b->getFirstAccess(),
            'total_duration' => static fn(
                Participant $a,
                Participant $b
            ) => $a->getTotalDuration($processing_time) <=> $b->getTotalDuration($processing_time),
            'remaining_duration' => static fn(
                Participant $a,
                Participant $b
            ) => $a->getRemainingDuration($processing_time, $reset_time_on_new_attempt)
                <=> $b->getRemainingDuration($processing_time, $reset_time_on_new_attempt),
            'last_access' => static fn(Participant $a, Participant $b) => $a->getLastAccess() <=> $b->getLastAccess(),
            'status_of_attempt' => fn(
                Participant $a,
                Participant $b
            ) => strcmp(
                $a->getAttemptOverviewInformation()?->getStatusOfAttempt()?->getTranslation($this->lng) ?? StatusOfAttempt::NOT_YET_STARTED->getTranslation($this->lng),
                $b->getAttemptOverviewInformation()?->getStatusOfAttempt()?->getTranslation($this->lng) ?? StatusOfAttempt::NOT_YET_STARTED->getTranslation($this->lng)
            ),
            'reached_points' => static fn(
                Participant $a,
                Participant $b
            ) => $a->getAttemptOverviewInformation()?->getReachedPoints()
                <=> $b->getAttemptOverviewInformation()?->getReachedPoints(),
            'nr_of_answered_questions' => static fn(
                Participant $a,
                Participant $b
            ) => $a->getAttemptOverviewInformation()?->getNrOfAnsweredQuestions()
                <=> $b->getAttemptOverviewInformation()?->getNrOfAnsweredQuestions(),
            'percent_of_available_points' => static fn(
                Participant $a,
                Participant $b
            ) => $a->getAttemptOverviewInformation()?->getReachedPointsInPercent()
                <=> $b->getAttemptOverviewInformation()?->getReachedPointsInPercent(),
            'test_passed' => static fn(
                Participant $a,
                Participant $b
            ) => $a->getAttemptOverviewInformation()?->hasPassingMark()
                <=> $b->getAttemptOverviewInformation()?->hasPassingMark(),
            'mark' => static fn(
                Participant $a,
                Participant $b
            ) => $a->getAttemptOverviewInformation()?->getMark() <=> $b->getAttemptOverviewInformation()?->getMark(),
            'matriculation' => static fn(
                Participant $a,
                Participant $b
            ) => $a->getMatriculation() <=> $b->getMatriculation(),
            'id_of_attempt' => static fn(
                Participant $a,
                Participant $b
            ) => $a->getAttemptOverviewInformation()?->getExamId() <=> $b->getAttemptOverviewInformation()?->getExamId(),
            'total_time_on_task' => static fn(
                Participant $a,
                Participant $b
            ) => $a->getAttemptOverviewInformation()?->getTotalTimeOnTask() <=> $b->getAttemptOverviewInformation()?->getTotalTimeOnTask()
        ];
    }

References Vendor\Package\$a, and Vendor\Package\$b.

getTableComponent()

ILIAS\Test\Participants\ParticipantTable::getTableComponent ( ServerRequestInterface  $request, ?array  $filter  )

private

Definition at line 346 of file ParticipantTable.php.

    {
        return $this->ui_factory
            ->table()
            ->data(
                $this,
                $this->lng->txt('list_of_participants'),
                $this->getColumns(),
            )
            ->withId(self::ID)
            ->withRequest($request)
            ->withFilter($filter);
    }

References ILIAS\Repository\lng().

Referenced by ILIAS\Test\Participants\ParticipantTable\getComponents().

Here is the call graph for this function:

Here is the caller graph for this function:

getTotalRowCount()

ILIAS\Test\Participants\ParticipantTable::getTotalRowCount	(	mixed	$additional_viewcontrol_data,
		mixed	$filter_data,
		mixed	$additional_parameters
	)

Mainly for the purpose of pagination-support, it is important to know about the total number of records available.

Given the nature of a DataTable, which is, opposite to a PresentationTable, rather administrative than explorative, this information will increase user experience quite a bit. However, you may return null, if the call is to costly, but expect the View Control to look a little different in this case.

Make sure that potential filters or user restrictions are being applied to the count.

Implements ILIAS\UI\Component\Table\DataRetrieval.

Definition at line 84 of file ParticipantTable.php.

     : ?int {
        return $this->repository->countParticipants($this->test_object->getTestId(), $filter_data);
    }

getViewControlledRecords()

ILIAS\Test\Participants\ParticipantTable::getViewControlledRecords ( ?array  $filter_data, Range  $range, Order  $order  )

private

Returns

iterable<Participant>

Definition at line 517 of file ParticipantTable.php.

                                                                                              : iterable
    {
        return $this->limitRecords(
            $this->orderRecords(
                $this->filterRecords(
                    $this->results_data_factory->addAttemptOverviewInformationToParticipants(
                        $this->results_presentation_settings,
                        $this->test_object,
                        $this->loadRecords($filter_data, $order)
                    ),
                    $filter_data
                ),
                $order
            ),
            $range
        );
    }

References ILIAS\UI\Implementation\Component\Table\$range.

limitRecords()

ILIAS\Test\Participants\ParticipantTable::limitRecords ( array  $records, Range  $range  )

private

Definition at line 586 of file ParticipantTable.php.

                                                               : array
    {
        return array_slice($records, $range->getStart(), $range->getLength());
    }

References ILIAS\UI\Implementation\Component\Table\$range, ILIAS\Data\Range\getLength(), and ILIAS\Data\Range\getStart().

Here is the call graph for this function:

loadRecords()

ILIAS\Test\Participants\ParticipantTable::loadRecords ( ?array  $filter, Order  $order  )

private

Definition at line 469 of file ParticipantTable.php.

                                                              : iterable
    {
        if ($this->records !== null) {
            return $this->records;
        }
 
        $records = iterator_to_array(
            $this->repository->getParticipants(
                $this->test_object->getTestId(),
                $filter,
                null,
                $order
            )
        );
 
        $this->records = array_filter(
            $records,
            fn(Participant $participant) => in_array(
                $participant->getUserId(),
                $this->buildAccessFilteredParticipantsList($records)
            )
        );
 
        return $this->records;
    }

References ILIAS\Test\Participants\Participant\getUserId(), and ILIAS\UI\examples\Deck\repository().

Here is the call graph for this function:

matchFilter()

ILIAS\Test\Participants\ParticipantTable::matchFilter ( Participant  $record, ?array  $filter  )

private

Definition at line 544 of file ParticipantTable.php.

                                                                     : bool
    {
        if ($filter === null) {
            return true;
        }
 
        $post_load_filters = $this->getPostLoadFilters();
        $allow = true;
 
        foreach ($filter as $key => $value) {
            if (!$value) {
                continue;
            }
 
            $post_load_filter = $post_load_filters[$key] ?? fn() => true;
            $allow = $allow && $post_load_filter($value, $record);
        }
 
        return $allow;
    }

orderRecords()

ILIAS\Test\Participants\ParticipantTable::orderRecords ( iterable  $records, Order  $order  )

private

Definition at line 565 of file ParticipantTable.php.

                                                                  : array
    {
        $post_load_order_fields = $this->getPostLoadOrderFields();
        $records = iterator_to_array($records);
 
        uasort($records, static function (Participant $a, Participant $b) use ($order, $post_load_order_fields) {
            foreach ($order->get() as $subject => $direction) {
                $post_load_order_field = $post_load_order_fields[$subject] ?? fn() => 0;
                $index = $post_load_order_field($a, $b);
 
                if ($index !== 0) {
                    return $direction === 'DESC' ? $index * -1 : $index;
                }
            }
 
            return 0;
        });
 
        return $records;
    }

References Vendor\Package\$a, Vendor\Package\$b, and ILIAS\Data\Order\get().

Here is the call graph for this function:

Field Documentation

$records

iterable ILIAS\Test\Participants\ParticipantTable::$records = null

private

Definition at line 42 of file ParticipantTable.php.

$scoring_enabled

bool ILIAS\Test\Participants\ParticipantTable::$scoring_enabled = false

private

Definition at line 43 of file ParticipantTable.php.

ID

const ILIAS\Test\Participants\ParticipantTable::ID = 'pt'

private

Definition at line 41 of file ParticipantTable.php.

---

The documentation for this class was generated from the following file:

• components/ILIAS/Test/src/Participants/ParticipantTable.php