Schedules and tasks

if (!parent::authorize()) {
    return false;
}

$server = $this->route()->parameter('server');
$schedule = $this->route()->parameter('schedule');

if ($server instanceof Server && $schedule instanceof Schedule) {
    $task = $this->route()->parameter('task');

    if ($schedule->server_id !== $server->id || ($task instanceof Task && $task->schedule_id !== $schedule->id)) {
        throw new NotFoundHttpException('The requested resource does not exist on the system.');
    }
}

return true;

$schedules = $server->schedules->loadMissing('tasks');

return $this->fractal->collection($schedules)
    ->transformWith($this->getTransformer(ScheduleTransformer::class))
    ->toArray();

if (!parent::authorize()) {
    return false;
}

$server = $this->route()->parameter('server');
$schedule = $this->route()->parameter('schedule');

if ($server instanceof Server && $schedule instanceof Schedule) {
    $task = $this->route()->parameter('task');

    if ($schedule->server_id !== $server->id || ($task instanceof Task && $task->schedule_id !== $schedule->id)) {
        throw new NotFoundHttpException('The requested resource does not exist on the system.');
    }
}

return true;

$model = $this->repository->create([
    'server_id' => $server->id,
    'name' => $request->input('name'),
    'cron_day_of_week' => $request->input('day_of_week'),
    'cron_month' => $request->input('month'),
    'cron_day_of_month' => $request->input('day_of_month'),
    'cron_hour' => $request->input('hour'),
    'cron_minute' => $request->input('minute'),
    'is_active' => (bool) $request->input('is_active'),
    'only_when_online' => (bool) $request->input('only_when_online'),
    'next_run_at' => $this->getNextRunAt($request),
]);

Activity::event('server:schedule.create')
    ->subject($model)
    ->property('name', $model->name)
    ->log();

return $this->fractal->item($model)
    ->transformWith($this->getTransformer(ScheduleTransformer::class))
    ->toArray();

if (!parent::authorize()) {
    return false;
}

$server = $this->route()->parameter('server');
$schedule = $this->route()->parameter('schedule');

if ($server instanceof Server && $schedule instanceof Schedule) {
    $task = $this->route()->parameter('task');

    if ($schedule->server_id !== $server->id || ($task instanceof Task && $task->schedule_id !== $schedule->id)) {
        throw new NotFoundHttpException('The requested resource does not exist on the system.');
    }
}

return true;

if ($schedule->server_id !== $server->id) {
    throw new NotFoundHttpException();
}

$schedule->loadMissing('tasks');

return $this->fractal->item($schedule)
    ->transformWith($this->getTransformer(ScheduleTransformer::class))
    ->toArray();

if (!parent::authorize()) {
    return false;
}

$server = $this->route()->parameter('server');
$schedule = $this->route()->parameter('schedule');

if ($server instanceof Server && $schedule instanceof Schedule) {
    $task = $this->route()->parameter('task');

    if ($schedule->server_id !== $server->id || ($task instanceof Task && $task->schedule_id !== $schedule->id)) {
        throw new NotFoundHttpException('The requested resource does not exist on the system.');
    }
}

return true;

$active = (bool) $request->input('is_active');

$data = [
    'name' => $request->input('name'),
    'cron_day_of_week' => $request->input('day_of_week'),
    'cron_month' => $request->input('month'),
    'cron_day_of_month' => $request->input('day_of_month'),
    'cron_hour' => $request->input('hour'),
    'cron_minute' => $request->input('minute'),
    'is_active' => $active,
    'only_when_online' => (bool) $request->input('only_when_online'),
    'next_run_at' => $this->getNextRunAt($request),
];

if ($schedule->is_active !== $active) {
    $data['is_processing'] = false;
}

$this->repository->update($schedule->id, $data);

Activity::event('server:schedule.update')
    ->subject($schedule)
    ->property(['name' => $schedule->name, 'active' => $active])
    ->log();

return $this->fractal->item($schedule->refresh())
    ->transformWith($this->getTransformer(ScheduleTransformer::class))
    ->toArray();

$this->service->handle($schedule, true);

Activity::event('server:schedule.execute')->subject($schedule)->property('name', $schedule->name)->log();

return new JsonResponse([], JsonResponse::HTTP_ACCEPTED);

if (!parent::authorize()) {
    return false;
}

$server = $this->route()->parameter('server');
$schedule = $this->route()->parameter('schedule');

if ($server instanceof Server && $schedule instanceof Schedule) {
    $task = $this->route()->parameter('task');

    if ($schedule->server_id !== $server->id || ($task instanceof Task && $task->schedule_id !== $schedule->id)) {
        throw new NotFoundHttpException('The requested resource does not exist on the system.');
    }
}

return true;

$this->repository->delete($schedule->id);

Activity::event('server:schedule.delete')->subject($schedule)->property('name', $schedule->name)->log();

return new JsonResponse([], Response::HTTP_NO_CONTENT);

if (!parent::authorize()) {
    return false;
}

$permission = Task::permissionForAction((string) $this->input('action'), $this->input('payload'));
if (is_null($permission)) {
    return true;
}

$server = $this->route()->parameter('server');

return $server instanceof Server && $this->user()->can($permission, $server);

$limit = config('pterodactyl.client_features.schedules.per_schedule_task_limit', 10);
if ($schedule->tasks()->count() >= $limit) {
    throw new ServiceLimitExceededException("Schedules may not have more than $limit tasks associated with them. Creating this task would put this schedule over the limit.");
}

if ($server->backup_limit === 0 && $request->action === 'backup') {
    throw new HttpForbiddenException("A backup task cannot be created when the server's backup limit is set to 0.");
}

$lastTask = $schedule->tasks()->orderByDesc('sequence_id')->first();

$task = $this->connection->transaction(function () use ($request, $schedule, $lastTask) {
    $sequenceId = ($lastTask->sequence_id ?? 0) + 1;
    $requestSequenceId = $request->integer('sequence_id', $sequenceId);

    if ($requestSequenceId < 1) {
        $requestSequenceId = 1;
    }

    if ($requestSequenceId < $sequenceId) {
        $schedule->tasks()
            ->where('sequence_id', '>=', $requestSequenceId)
            ->increment('sequence_id');
        $sequenceId = $requestSequenceId;
    }

    return $this->repository->create([
        'schedule_id' => $schedule->id,
        'sequence_id' => $sequenceId,
        'action' => $request->input('action'),
        'payload' => $request->input('payload') ?? '',
        'time_offset' => $request->input('time_offset'),
        'continue_on_failure' => $request->boolean('continue_on_failure'),
    ]);
});

Activity::event('server:task.create')
    ->subject($schedule, $task)
    ->property(['name' => $schedule->name, 'action' => $task->action, 'payload' => $task->payload])
    ->log();

return $this->fractal->item($task)
    ->transformWith($this->getTransformer(TaskTransformer::class))
    ->toArray();

if (!parent::authorize()) {
    return false;
}

$permission = Task::permissionForAction((string) $this->input('action'), $this->input('payload'));
if (is_null($permission)) {
    return true;
}

$server = $this->route()->parameter('server');

return $server instanceof Server && $this->user()->can($permission, $server);

if ($schedule->id !== $task->schedule_id || $server->id !== $schedule->server_id) {
    throw new NotFoundHttpException();
}

if ($server->backup_limit === 0 && $request->action === 'backup') {
    throw new HttpForbiddenException("A backup task cannot be created when the server's backup limit is set to 0.");
}

$this->connection->transaction(function () use ($request, $schedule, $task) {
    $sequenceId = $request->integer('sequence_id', $task->sequence_id);

    if ($sequenceId < 1) {
        $sequenceId = 1;
    }

    if ($sequenceId < $task->sequence_id) {
        $schedule->tasks()
            ->where('sequence_id', '>=', $sequenceId)
            ->where('sequence_id', '<', $task->sequence_id)
            ->increment('sequence_id');
    } elseif ($sequenceId > $task->sequence_id) {
        $schedule->tasks()
            ->where('sequence_id', '>', $task->sequence_id)
            ->where('sequence_id', '<=', $sequenceId)
            ->decrement('sequence_id');
    }

    $this->repository->update($task->id, [
        'sequence_id' => $sequenceId,
        'action' => $request->input('action'),
        'payload' => $request->input('payload') ?? '',
        'time_offset' => $request->input('time_offset'),
        'continue_on_failure' => $request->boolean('continue_on_failure'),
    ]);
});

Activity::event('server:task.update')
    ->subject($schedule, $task)
    ->property(['name' => $schedule->name, 'action' => $task->action, 'payload' => $task->payload])
    ->log();

return $this->fractal->item($task->refresh())
    ->transformWith($this->getTransformer(TaskTransformer::class))
    ->toArray();

if ($task->schedule_id !== $schedule->id || $schedule->server_id !== $server->id) {
    throw new NotFoundHttpException();
}

if (!$request->user()->can(Permission::ACTION_SCHEDULE_UPDATE, $server)) {
    throw new HttpForbiddenException('You do not have permission to perform this action.');
}

$schedule->tasks()
    ->where('sequence_id', '>', $task->sequence_id)
    ->decrement('sequence_id');
$task->delete();

Activity::event('server:task.delete')->subject($schedule, $task)->property('name', $schedule->name)->log();

return new JsonResponse(null, Response::HTTP_NO_CONTENT);