diff --git a/API/TimesheetApiController.php b/API/TimesheetApiController.php
new file mode 100644
index 0000000..ddff390
--- /dev/null
+++ b/API/TimesheetApiController.php
@@ -0,0 +1,489 @@
+<?php
+
+/*
+ * This file is part of the Kimai time-tracking app.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace KimaiPlugin\ApprovalBundle\API;
+
+use App\API\BaseApiController;
+use App\Entity\Timesheet;
+use App\Repository\ActivityRepository;
+use App\Repository\CustomerRepository;
+use App\Repository\ProjectRepository;
+use App\Repository\Query\TimesheetQuery;
+use App\Repository\TagRepository;
+use App\Repository\TimesheetRepository;
+use App\Repository\UserRepository;
+use App\Utils\SearchTerm;
+use FOS\RestBundle\Controller\Annotations as Rest;
+use FOS\RestBundle\Request\ParamFetcherInterface;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalRepository;
+use FOS\RestBundle\View\View;
+use Pagerfanta\Adapter\ArrayAdapter;
+use Pagerfanta\Pagerfanta;
+use FOS\RestBundle\View\ViewHandlerInterface;
+use OpenApi\Attributes as OA;
+use Symfony\Component\ExpressionLanguage\Expression;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+use Symfony\Component\Routing\Attribute\Route;
+use Symfony\Component\Security\Http\Attribute\IsGranted;
+use Symfony\Component\Validator\Constraints;
+
+#[Route(path: '/approval/timesheets')]
+#[IsGranted('API')]
+#[OA\Tag(name: 'Timesheet')]
+final class TimesheetApiController extends BaseApiController
+{
+    public const GROUPS_ENTITY = ['Default', 'Entity', 'Timesheet', 'Timesheet_Entity', 'Not_Expanded'];
+    public const GROUPS_ENTITY_FULL = ['Default', 'Entity', 'Timesheet', 'Timesheet_Entity', 'Expanded'];
+    public const GROUPS_FORM = ['Default', 'Entity', 'Timesheet', 'Not_Expanded'];
+    public const GROUPS_COLLECTION = ['Default', 'Collection', 'Timesheet', 'Not_Expanded'];
+    public const GROUPS_COLLECTION_FULL = ['Default', 'Collection', 'Timesheet', 'Expanded'];
+
+    public function __construct(
+        private readonly ViewHandlerInterface $viewHandler,
+        private readonly TimesheetRepository $repository,
+        private readonly TagRepository $tagRepository,
+        private readonly ApprovalRepository $approvalRepository
+    ) {
+    }
+
+    /**
+     * Fetch timesheets
+     */
+    #[IsGranted(new Expression("is_granted('view_own_timesheet') or is_granted('view_other_timesheet')"))]
+    #[OA\Response(response: 200, description: 'Returns a collection of timesheets. The datetime fields are given in the users local time including the timezone offset (ISO-8601).', content: new OA\JsonContent(type: 'array', items: new OA\Items(ref: '#/components/schemas/TimesheetCollection')))]
+    #[Route(methods: ['GET'], path: '', name: 'approval_get_timesheets')]
+    #[Rest\QueryParam(name: 'user', requirements: '\d+|all', strict: true, nullable: true, description: "User ID to filter timesheets. Needs permission 'view_other_timesheet', pass 'all' to fetch data for all user (default: current user)")]
+    #[Rest\QueryParam(name: 'users', map: true, requirements: '\d+', strict: true, nullable: true, default: [], description: 'List of user IDs to filter, e.g.: users[]=1&users[]=2 (ignored if user=all)')]
+    #[Rest\QueryParam(name: 'customer', requirements: '\d+', strict: true, nullable: true, description: 'Customer ID to filter timesheets')]
+    #[Rest\QueryParam(name: 'customers', map: true, requirements: '\d+', strict: true, nullable: true, default: [], description: 'List of customer IDs to filter, e.g.: customers[]=1&customers[]=2')]
+    #[Rest\QueryParam(name: 'project', requirements: '\d+', strict: true, nullable: true, description: 'Project ID to filter timesheets')]
+    #[Rest\QueryParam(name: 'projects', map: true, requirements: '\d+', strict: true, nullable: true, default: [], description: 'List of project IDs to filter, e.g.: projects[]=1&projects[]=2')]
+    #[Rest\QueryParam(name: 'activity', requirements: '\d+', strict: true, nullable: true, description: 'Activity ID to filter timesheets')]
+    #[Rest\QueryParam(name: 'activities', map: true, requirements: '\d+', strict: true, nullable: true, default: [], description: 'List of activity IDs to filter, e.g.: activities[]=1&activities[]=2')]
+    #[Rest\QueryParam(name: 'page', requirements: '\d+', strict: true, nullable: true, description: 'The page to display, renders a 404 if not found (default: 1)')]
+    #[Rest\QueryParam(name: 'size', requirements: '\d+', strict: true, nullable: true, description: 'The amount of entries for each page (default: 50, max: 500)')]
+    #[Rest\QueryParam(name: 'tags', map: true, strict: true, nullable: true, default: [], description: 'List of tag names, e.g. tags[]=bar&tags[]=foo')]
+    #[Rest\QueryParam(name: 'orderBy', requirements: 'id|begin|end|rate', strict: true, nullable: true, description: 'The field by which results will be ordered. Allowed values: id, begin, end, rate (default: begin)')]
+    #[Rest\QueryParam(name: 'order', requirements: 'ASC|DESC', strict: true, nullable: true, description: 'The result order. Allowed values: ASC, DESC (default: DESC)')]
+    #[Rest\QueryParam(name: 'begin', requirements: [new Constraints\DateTime(format: 'Y-m-d\TH:i:s')], strict: true, nullable: true, description: 'Only records started at or after this date-time will be included (format: HTML5 datetime-local, e.g. YYYY-MM-DDThh:mm:ss)')]
+    #[Rest\QueryParam(name: 'end', requirements: [new Constraints\DateTime(format: 'Y-m-d\TH:i:s')], strict: true, nullable: true, description: 'Only records started at or before this date-time will be included (format: HTML5 datetime-local, e.g. YYYY-MM-DDThh:mm:ss)')]
+    #[Rest\QueryParam(name: 'exported', requirements: '0|1', strict: true, nullable: true, description: 'Use this flag if you want to filter for export state. Allowed values: 0=not exported, 1=exported (default: all)')]
+    #[Rest\QueryParam(name: 'active', requirements: '0|1', strict: true, nullable: true, description: 'Filter for running/active records. Allowed values: 0=stopped, 1=active (default: all)')]
+    #[Rest\QueryParam(name: 'billable', requirements: '0|1', strict: true, nullable: true, description: 'Filter for non-/billable records. Allowed values: 0=non-billable, 1=billable (default: all)')]
+    #[Rest\QueryParam(name: 'full', requirements: '0|1|true|false', strict: true, nullable: true, description: 'Allows to fetch full objects including subresources. Allowed values: 0|1|false|true (default: false)')]
+    #[Rest\QueryParam(name: 'approved', requirements: '0|1|true|false', strict: true, nullable: true, description: 'Filter by approval status. Allowed values: 0|1|false|true (default: all)')]
+    #[Rest\QueryParam(name: 'term', description: 'Free search term', nullable: true)]
+    #[Rest\QueryParam(name: 'modified_after', requirements: [new Constraints\DateTime(format: 'Y-m-d\TH:i:s')], strict: true, nullable: true, description: 'Only records changed after this date will be included. You need to pass in a UTC date-time, as this field is stored in UTC (format: HTML5 datetime-local, e.g. YYYY-MM-DDThh:mm:ss)')]
+    public function cgetAction(ParamFetcherInterface $paramFetcher, CustomerRepository $customerRepository, ProjectRepository $projectRepository, ActivityRepository $activityRepository, UserRepository $userRepository): Response
+    {
+        $query = new TimesheetQuery(false);
+        $this->prepareQuery($query, $paramFetcher);
+
+        $seeAll = $this->applyUserFilters($query, $paramFetcher, $userRepository);
+        $this->applyUserFallback($query, $seeAll);
+
+        $this->applyCustomerFilters($query, $paramFetcher, $customerRepository);
+        $this->applyProjectFilters($query, $paramFetcher, $projectRepository);
+        $this->applyActivityFilters($query, $paramFetcher, $activityRepository);
+        $this->applyTagFilters($query, $paramFetcher);
+        $this->applyDateFilters($query, $paramFetcher);
+        $this->applyStateFilters($query, $paramFetcher);
+        $this->applySearchFilters($query, $paramFetcher);
+        $this->applyModifiedAfter($query, $paramFetcher);
+
+        [$data, $results, $approvalMap] = $this->applyApprovalFilter($query, $paramFetcher);
+
+        $view = new View($results, Response::HTTP_OK);
+        $this->applyCollectionGroups($view, $paramFetcher);
+        $this->applyPaginationHeaders($view, $data);
+        $response = $this->viewHandler->handle($view);
+
+        return $this->addApprovalToJsonResponse($response, $results, $approvalMap);
+    }
+
+    private function applyUserFilters(TimesheetQuery $query, ParamFetcherInterface $paramFetcher, UserRepository $userRepository): bool
+    {
+        $seeAll = false;
+
+        if ($this->isGranted('view_other_timesheet')) {
+            /** @var array<int> $users */
+            $users = $paramFetcher->get('users');
+            $userId = $paramFetcher->get('user');
+
+            if ('all' === $userId) {
+                $seeAll = true;
+            } elseif (\is_string($userId) && $userId !== '') {
+                $users[] = (int) $userId;
+            }
+
+            if (!$seeAll) {
+                foreach ($userRepository->findByIds($users) as $user) {
+                    $query->addUser($user);
+                }
+            }
+        }
+
+        return $seeAll;
+    }
+
+    private function applyUserFallback(TimesheetQuery $query, bool $seeAll): void
+    {
+        if ($seeAll) {
+            $query->setUser(null);
+
+            return;
+        }
+
+        if (!$query->hasUsers()) {
+            $query->setUser($this->getUser());
+        }
+    }
+
+    private function applyCustomerFilters(TimesheetQuery $query, ParamFetcherInterface $paramFetcher, CustomerRepository $customerRepository): void
+    {
+        /** @var array<int> $customers */
+        $customers = $paramFetcher->get('customers');
+        $customer = $paramFetcher->get('customer');
+        if (\is_string($customer) && $customer !== '') {
+            $customers[] = $customer;
+        }
+
+        foreach (array_unique($customers) as $customerId) {
+            $customer = $customerRepository->find($customerId);
+            if ($customer === null) {
+                throw $this->createNotFoundException('Unknown customer: ' . $customerId);
+            }
+            $query->addCustomer($customer);
+        }
+    }
+
+    private function applyProjectFilters(TimesheetQuery $query, ParamFetcherInterface $paramFetcher, ProjectRepository $projectRepository): void
+    {
+        /** @var array<int> $projects */
+        $projects = $paramFetcher->get('projects');
+        $project = $paramFetcher->get('project');
+        if (\is_string($project) && $project !== '') {
+            $projects[] = $project;
+        }
+
+        foreach (array_unique($projects) as $projectId) {
+            $project = $projectRepository->find($projectId);
+            if ($project === null) {
+                throw $this->createNotFoundException('Unknown project: ' . $project);
+            }
+            $query->addProject($project);
+        }
+    }
+
+    private function applyActivityFilters(TimesheetQuery $query, ParamFetcherInterface $paramFetcher, ActivityRepository $activityRepository): void
+    {
+        /** @var array<int> $activities */
+        $activities = $paramFetcher->get('activities');
+        $activity = $paramFetcher->get('activity');
+        if (\is_string($activity) && $activity !== '') {
+            $activities[] = $activity;
+        }
+
+        foreach (array_unique($activities) as $activityId) {
+            $activity = $activityRepository->find($activityId);
+            if ($activity === null) {
+                throw $this->createNotFoundException('Unknown activity: ' . $activity);
+            }
+            $query->addActivity($activity);
+        }
+    }
+
+    private function applyTagFilters(TimesheetQuery $query, ParamFetcherInterface $paramFetcher): void
+    {
+        /** @var array<string> $tags */
+        $tags = $paramFetcher->get('tags');
+        if (!\is_array($tags) || \count($tags) === 0) {
+            return;
+        }
+
+        $tagsByName = $this->tagRepository->findTagsByName($tags, true);
+        if (\count($tagsByName) === 0) {
+            throw new BadRequestHttpException('Given tags were not found');
+        }
+        foreach ($tagsByName as $tag) {
+            $query->addTag($tag);
+        }
+    }
+
+    private function applyDateFilters(TimesheetQuery $query, ParamFetcherInterface $paramFetcher): void
+    {
+        $factory = $this->getDateTimeFactory();
+
+        $begin = $paramFetcher->get('begin');
+        if (\is_string($begin) && $begin !== '') {
+            $query->setBegin($factory->createDateTime($begin));
+        }
+
+        $end = $paramFetcher->get('end');
+        if (\is_string($end) && $end !== '') {
+            $query->setEnd($factory->createDateTime($end));
+        }
+    }
+
+    private function applyStateFilters(TimesheetQuery $query, ParamFetcherInterface $paramFetcher): void
+    {
+        $active = $paramFetcher->get('active');
+        if (\is_string($active) && $active !== '') {
+            $active = (int) $active;
+            if ($active === 1) {
+                $query->setState(TimesheetQuery::STATE_RUNNING);
+            } elseif ($active === 0) {
+                $query->setState(TimesheetQuery::STATE_STOPPED);
+            }
+        }
+
+        $billable = $paramFetcher->get('billable');
+        if (\is_string($billable) && $billable !== '') {
+            $billable = (int) $billable;
+            if ($billable === 1) {
+                $query->setBillable(true);
+            } elseif ($billable === 0) {
+                $query->setBillable(false);
+            }
+        }
+
+        $exported = $paramFetcher->get('exported');
+        if (\is_string($exported) && $exported !== '') {
+            $exported = (int) $exported;
+            if ($exported === 1) {
+                $query->setExported(TimesheetQuery::STATE_EXPORTED);
+            } elseif ($exported === 0) {
+                $query->setExported(TimesheetQuery::STATE_NOT_EXPORTED);
+            }
+        }
+    }
+
+    private function applySearchFilters(TimesheetQuery $query, ParamFetcherInterface $paramFetcher): void
+    {
+        $term = $paramFetcher->get('term');
+        if (\is_string($term) && $term !== '') {
+            $query->setSearchTerm(new SearchTerm($term));
+        }
+    }
+
+    private function applyModifiedAfter(TimesheetQuery $query, ParamFetcherInterface $paramFetcher): void
+    {
+        $modifiedAfter = $paramFetcher->get('modified_after');
+        if (\is_string($modifiedAfter)) {
+            $query->setModifiedAfter(new \DateTimeImmutable($modifiedAfter, new \DateTimeZone('UTC')));
+        }
+    }
+
+    private function applyCollectionGroups(View $view, ParamFetcherInterface $paramFetcher): void
+    {
+        $full = $paramFetcher->get('full');
+        if ($full === '1' || $full === 'true') {
+            $view->getContext()->setGroups(self::GROUPS_COLLECTION_FULL);
+
+            return;
+        }
+
+        $view->getContext()->setGroups(self::GROUPS_COLLECTION);
+    }
+
+    private function applyPaginationHeaders(View $view, Pagerfanta $data): void
+    {
+        $view->setHeader('X-Page', (string) $data->getCurrentPage());
+        $view->setHeader('X-Total-Count', (string) $data->getNbResults());
+        $view->setHeader('X-Total-Pages', (string) $data->getNbPages());
+        $view->setHeader('X-Per-Page', (string) $data->getMaxPerPage());
+    }
+
+    private function applyApprovalFilter(TimesheetQuery $query, ParamFetcherInterface $paramFetcher): array
+    {
+        $approved = $this->getApprovedFilter($paramFetcher);
+        if ($approved === null) {
+            $data = $this->repository->getPagerfantaForQuery($query);
+            $results = (array) $data->getCurrentPageResults();
+            $approvalMap = $this->buildApprovalMap($results);
+
+            return [$data, $results, $approvalMap];
+        }
+
+        $timesheets = $this->repository->getTimesheetsForQuery($query);
+        $approvalMap = $this->buildApprovalMap($timesheets);
+        $filtered = array_values(array_filter(
+            $timesheets,
+            function (Timesheet $timesheet) use ($approvalMap, $approved): bool {
+                return ($approvalMap[$timesheet->getId()] ?? false) === $approved;
+            }
+        ));
+
+        $pager = $this->createPagerfanta($filtered, $paramFetcher);
+        $results = (array) $pager->getCurrentPageResults();
+
+        return [$pager, $results, $approvalMap];
+    }
+
+    private function getApprovedFilter(ParamFetcherInterface $paramFetcher): ?bool
+    {
+        $approved = $paramFetcher->get('approved');
+        if (!\is_string($approved) || $approved === '') {
+            return null;
+        }
+
+        if ($approved === '1' || $approved === 'true') {
+            return true;
+        }
+
+        if ($approved === '0' || $approved === 'false') {
+            return false;
+        }
+
+        return null;
+    }
+
+    private function createPagerfanta(array $timesheets, ParamFetcherInterface $paramFetcher): Pagerfanta
+    {
+        $pager = new Pagerfanta(new ArrayAdapter($timesheets));
+        $pager->setMaxPerPage($this->getPageSize($paramFetcher));
+        $pager->setCurrentPage($this->getPageNumber($paramFetcher));
+
+        return $pager;
+    }
+
+    private function getPageNumber(ParamFetcherInterface $paramFetcher): int
+    {
+        $page = $paramFetcher->get('page');
+        if (\is_string($page) && $page !== '') {
+            return max(1, (int) $page);
+        }
+
+        return 1;
+    }
+
+    private function getPageSize(ParamFetcherInterface $paramFetcher): int
+    {
+        $size = $paramFetcher->get('size');
+        if (\is_string($size) && $size !== '') {
+            return min(500, max(1, (int) $size));
+        }
+
+        return 50;
+    }
+
+    private function buildApprovalMap(array $timesheets): array
+    {
+        if ($timesheets === []) {
+            return [];
+        }
+
+        $userIds = [];
+        $minDate = null;
+        $maxDate = null;
+
+        foreach ($timesheets as $timesheet) {
+            if (!$timesheet instanceof Timesheet) {
+                continue;
+            }
+
+            $userIds[] = $timesheet->getUser()->getId();
+            $date = $timesheet->getBegin();
+            $dateOnly = new \DateTimeImmutable($date->format('Y-m-d'));
+
+            if ($minDate === null || $dateOnly < $minDate) {
+                $minDate = $dateOnly;
+            }
+
+            if ($maxDate === null || $dateOnly > $maxDate) {
+                $maxDate = $dateOnly;
+            }
+        }
+
+        if ($minDate === null || $maxDate === null) {
+            return [];
+        }
+
+        $userIds = array_values(array_unique($userIds));
+        $approvals = $this->approvalRepository->findApprovedForUsersAndDateRange($userIds, $minDate, $maxDate);
+
+        $rangesByUser = [];
+        foreach ($approvals as $approval) {
+            $userId = $approval->getUser()->getId();
+            $rangesByUser[$userId][] = [
+                $approval->getStartDate()->format('Y-m-d'),
+                $approval->getEndDate()->format('Y-m-d'),
+            ];
+        }
+
+        $approvalMap = [];
+        foreach ($timesheets as $timesheet) {
+            if (!$timesheet instanceof Timesheet) {
+                continue;
+            }
+
+            $timesheetId = $timesheet->getId();
+            $userId = $timesheet->getUser()->getId();
+            $date = $timesheet->getBegin()->format('Y-m-d');
+
+            $approved = false;
+            foreach ($rangesByUser[$userId] ?? [] as [$startDate, $endDate]) {
+                if ($date >= $startDate && $date <= $endDate) {
+                    $approved = true;
+                    break;
+                }
+            }
+
+            $approvalMap[$timesheetId] = $approved;
+        }
+
+        return $approvalMap;
+    }
+
+    private function addApprovalToJsonResponse(Response $response, array $results, array $approvalMap): Response
+    {
+        if ($results === []) {
+            return $response;
+        }
+
+        $contentType = $response->headers->get('Content-Type', '');
+        if (!str_contains($contentType, 'json')) {
+            return $response;
+        }
+
+        $content = $response->getContent();
+        if (!\is_string($content) || $content === '') {
+            return $response;
+        }
+
+        try {
+            $payload = json_decode($content, true, 512, \JSON_THROW_ON_ERROR);
+        } catch (\JsonException) {
+            return $response;
+        }
+
+        if (!\is_array($payload)) {
+            return $response;
+        }
+
+        foreach ($payload as $index => &$item) {
+            if (!isset($results[$index]) || !$results[$index] instanceof Timesheet || !\is_array($item)) {
+                continue;
+            }
+
+            $timesheetId = $results[$index]->getId();
+            $item['approved'] = $approvalMap[$timesheetId] ?? false;
+        }
+        unset($item);
+
+        try {
+            $response->setContent(json_encode($payload, \JSON_THROW_ON_ERROR));
+        } catch (\JsonException) {
+            return $response;
+        }
+
+        return $response;
+    }
+}
\ No newline at end of file
diff --git a/Controller/ApprovalController.php b/Controller/ApprovalController.php
index ca94e60..1a78d29 100644
--- a/Controller/ApprovalController.php
+++ b/Controller/ApprovalController.php
@@ -9,7 +9,13 @@
 
 namespace KimaiPlugin\ApprovalBundle\Controller;
 
+use App\Entity\User;
+use App\Entity\Team;
+use App\Form\Model\DateRange;
 use App\Repository\UserRepository;
+use App\Repository\TimesheetRepository;
+use App\Repository\Query\BaseQuery;
+use App\Repository\Query\TimesheetQuery;
 use DateTime;
 use KimaiPlugin\ApprovalBundle\Entity\Approval;
 use KimaiPlugin\ApprovalBundle\Entity\ApprovalHistory;
@@ -18,9 +24,11 @@
 use KimaiPlugin\ApprovalBundle\Repository\ApprovalRepository;
 use KimaiPlugin\ApprovalBundle\Repository\ApprovalStatusRepository;
 use KimaiPlugin\ApprovalBundle\Repository\LockdownRepository;
+use KimaiPlugin\ApprovalBundle\Toolbox\BreakTimeCheckToolGER;
 use KimaiPlugin\ApprovalBundle\Toolbox\EmailTool;
 use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
 use KimaiPlugin\ApprovalBundle\Enumeration\ConfigEnum;
+use KimaiPlugin\ApprovalBundle\Service\AutoApprovalService;
 use Symfony\Component\HttpFoundation\RedirectResponse;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\Routing\Attribute\Route;
@@ -37,7 +45,10 @@ public function __construct(
         private UserRepository $userRepository,
         private EmailTool $emailTool,
         private SettingsTool $settingsTool,
-        private LockdownRepository $lockdownRepository
+        private LockdownRepository $lockdownRepository,
+        private TimesheetRepository $timesheetRepository,
+        private BreakTimeCheckToolGER $breakTimeCheckToolGER,
+        private AutoApprovalService $autoApprovalService
     ) {
     }
 
@@ -47,7 +58,7 @@ public function addToApprove(Request $request): RedirectResponse
         $userId = $request->query->get('user');
         $date = $request->query->get('date');
         $approval = $this->createAddToApproveForm($userId, $date);
-        if ($this->settingsTool->getBooleanConfiguration(ConfigEnum::APPROVAL_MAIL_SUBMITTED_NY, true)){
+        if ($this->settingsTool->getBooleanConfiguration(ConfigEnum::APPROVAL_MAIL_SUBMITTED_NY, true)) {
             $this->emailTool->sendApproveWeekEmail($approval, $this->approvalRepository);
         }
         $this->lockdownRepository->updateLockWeek($approval, $this->approvalRepository);
@@ -58,6 +69,89 @@ public function addToApprove(Request $request): RedirectResponse
         ]));
     }
 
+    #[Route(path: '/auto_approve', name: 'auto_approve', methods: ['GET'])]
+    public function autoApproveAction(Request $request): RedirectResponse
+    {
+        $users = $this->getUsersForAutoApproval();
+        $query = $request->getSession()->get('query');
+
+        if (!empty($query->getUsers())) {
+            $users = $query->getUsers();
+        }
+
+        $submittedApprovals = $this->approvalRepository->getUserApprovalsFiltered($users, $query);
+
+        $result = $this->autoApprovalService->processApprovals($submittedApprovals);
+
+        // Process approved approvals
+        foreach ($result['processedApprovals'] as $approval) {
+            $this->finalizeApproval($approval, $request->query->get('date'));
+        }
+
+        return $this->buildAutoApprovalRedirect($query, $result['successful'], $result['failed'], $request);
+    }
+
+    private function getUsersForAutoApproval(): array
+    {
+        $includeSelf = $this->settingsTool->getConfiguration(ConfigEnum::APPROVAL_TEAMLEAD_SELF_APPROVE_NY) == '1';
+        return $this->getUsers($includeSelf);
+    }
+
+    private function finalizeApproval(Approval $approval, ?string $date): void
+    {
+        $approval = $this->createNewApproveHistory($approval->getId(), ApprovalStatus::APPROVED);
+
+        if ($this->settingsTool->getBooleanConfiguration(ConfigEnum::APPROVAL_MAIL_ACTION_NY, true)) {
+            $this->emailTool->sendStatusChangedEmail(
+                $approval,
+                $this->getUser()->getDisplayName(),
+                $this->approvalRepository->getUrl(
+                    (string) $approval->getUser()->getId(),
+                    $approval->getStartDate()->format('Y-m-d')
+                )
+            );
+        }
+
+        $this->lockdownRepository->updateLockWeek($approval, $this->approvalRepository);
+        $this->emailIfClosedMonth($date);
+    }
+
+    private function buildAutoApprovalRedirect($query, int $successCount, int $failCount, Request $request): RedirectResponse
+    {
+        if (!$query) {
+            return new RedirectResponse($this->urlGenerator->generate('approval_bundle_to_approve'));
+        }
+
+        $params = [
+            'page' => $query->getPage(),
+            'orderBy' => $query->getOrderBy(),
+            'order' => $query->getOrder(),
+            'auto_approve_success' => $successCount,
+            'auto_approve_fail' => $failCount,
+        ];
+
+        if ($query->getSearchTerm() && !empty($query->getSearchTerm()->getSearchTerm())) {
+            $params['searchTerm'] = $query->getSearchTerm()->getSearchTerm();
+            $params['performSearch'] = 'performSearch';
+        }
+
+        if ($query->getBegin() && $query->getEnd()) {
+            $params['daterange'] = $query->getBegin()->format('d.m.Y') . ' - ' . $query->getEnd()->format('d.m.Y');
+        }
+
+        if (!empty($query->getUsers())) {
+            $params['users'] = array_map(fn($user) => $user->getId(), $query->getUsers());
+        }
+
+        if (!empty($query->getStatus())) {
+            $params['status'] = $query->getStatus();
+        }
+
+        $params['_token'] = $request->getSession()->get('_csrf/toolbar');
+
+        return new RedirectResponse($this->urlGenerator->generate('approval_bundle_to_approve', $params));
+    }
+
     #[Route(path: '/approve/{approveId}', defaults: ['approveId' => 0], name: 'approve', methods: ['GET'])]
     public function approveAction(Request $request, string $approveId): RedirectResponse
     {
@@ -71,7 +165,7 @@ public function approveAction(Request $request, string $approveId): RedirectResp
         );
         if ($approval) {
             $approval = $this->createNewApproveHistory($approveId, ApprovalStatus::APPROVED);
-            if ($this->settingsTool->getBooleanConfiguration(ConfigEnum::APPROVAL_MAIL_ACTION_NY, true)){
+            if ($this->settingsTool->getBooleanConfiguration(ConfigEnum::APPROVAL_MAIL_ACTION_NY, true)) {
                 $this->emailTool->sendStatusChangedEmail(
                     $approval,
                     $this->getUser()->getDisplayName(),
@@ -129,7 +223,7 @@ public function deniedAction(Request $request, string $approveId): RedirectRespo
         );
         if ($approval) {
             $approval = $this->createNewApproveHistory($approveId, ApprovalStatus::DENIED, $request->query->get('input'));
-            if ($this->settingsTool->getBooleanConfiguration(ConfigEnum::APPROVAL_MAIL_ACTION_NY, true)){
+            if ($this->settingsTool->getBooleanConfiguration(ConfigEnum::APPROVAL_MAIL_ACTION_NY, true)) {
                 $this->emailTool->sendStatusChangedEmail(
                     $approval,
                     $this->getUser()->getDisplayName(),
@@ -211,4 +305,58 @@ private function emailIfClosedMonth($date): void
             }
         }
     }
+
+    private function getUsers(bool $includeOwnForTeam = true): array
+    {
+        if ($this->canManageAllPerson()) {
+            $users = $this->userRepository->findAll();
+        } elseif ($this->canManageTeam()) {
+            $users = [];
+            $user = $this->getUser();
+            /** @var Team $team */
+            foreach ($user->getTeams() as $team) {
+                if (\in_array($user, $team->getTeamleads())) {
+                    array_push($users, ...$team->getUsers());
+                } else {
+                    $users[] = $user;
+                }
+            }
+
+            if (empty($users)) {
+                $users = [$user];
+            }
+
+            $users = array_unique($users);
+
+            if (!$includeOwnForTeam) {
+                // remove the active user from the list
+                $index = array_search($this->getUser(), $users);
+                if ($index !== false) {
+                    unset($users[$index]);
+                }
+            }
+        } else {
+            $users = [$this->getUser()];
+        }
+
+        $users = array_reduce($users, function ($current, $user) {
+            $includeSuperAdmin = $this->settingsTool->getConfiguration(ConfigEnum::APPROVAL_INCLUDE_ADMIN_NY) == '1';
+            if ($user->isEnabled() && (!$user->isSuperAdmin() || $includeSuperAdmin)) {
+                $current[] = $user;
+            }
+
+            return $current;
+        }, []);
+
+        if (!empty($users)) {
+            usort(
+                $users,
+                function (User $userA, User $userB) {
+                    return strcmp(strtoupper($userA->getUsername()), strtoupper($userB->getUsername()));
+                }
+            );
+        }
+
+        return $users;
+    }
 }
diff --git a/Controller/BaseApprovalController.php b/Controller/BaseApprovalController.php
index 482c874..9572295 100644
--- a/Controller/BaseApprovalController.php
+++ b/Controller/BaseApprovalController.php
@@ -30,7 +30,8 @@ protected function getDefaultTemplateParams(SettingsTool $settingsTool): array
             'showToApproveTab' => $this->canManageAllPerson() || $this->canManageTeam(),
             'showSettings' => $this->isGranted('ROLE_SUPER_ADMIN'),
             'showSettingsWorkdays' => $this->isGranted('ROLE_SUPER_ADMIN') && $settingsTool->isOvertimeCheckActive(),
-            'showOvertime' => $settingsTool->isOvertimeCheckActive()
+            'showOvertime' => $settingsTool->isOvertimeCheckActive(),
+            'showWorkingTimeActCheckGER' => $this->isGranted('ROLE_SUPER_ADMIN') && $settingsTool->isBreakTimeCheckActive(),
         ];
     }
 }
diff --git a/Controller/WeekReportController.php b/Controller/WeekReportController.php
index 86e33c3..1bec7f0 100644
--- a/Controller/WeekReportController.php
+++ b/Controller/WeekReportController.php
@@ -38,6 +38,7 @@
 use KimaiPlugin\ApprovalBundle\Repository\ApprovalWorkdayHistoryRepository;
 use KimaiPlugin\ApprovalBundle\Repository\ReportRepository;
 use KimaiPlugin\ApprovalBundle\Repository\Query\ApprovalQuery;
+use KimaiPlugin\ApprovalBundle\Service\ApprovalDataService;
 use KimaiPlugin\ApprovalBundle\Toolbox\BreakTimeCheckToolGER;
 use KimaiPlugin\ApprovalBundle\Toolbox\Formatting;
 use KimaiPlugin\ApprovalBundle\Toolbox\SecurityTool;
@@ -65,7 +66,8 @@ public function __construct(
         private TimesheetRepository $timesheetRepository,
         private ApprovalTimesheetRepository $approvalTimesheetRepository,
         private BreakTimeCheckToolGER $breakTimeCheckToolGER,
-        private ReportRepository $reportRepository
+        private ReportRepository $reportRepository,
+        private ApprovalDataService $approvalDataService
     ) {
     }
 
@@ -176,137 +178,63 @@ public function toApprove(ApprovalQuery $query, Request $request): Response
             return $this->redirectToRoute('approval_bundle_to_approve');
         }
 
-        if ($this->settingsTool->getConfiguration(ConfigEnum::APPROVAL_TEAMLEAD_SELF_APPROVE_NY) == '1') {
-            $users = $this->getUsers(true);
-        } else {
-            $users = $this->getUsers(false);
-        }
-
-        $warningNoUsers = false;
-        if (empty($users)) {
-            $warningNoUsers = true;
-            $users = [$this->getUser()];
-        }
+        $request->getSession()->set('query', $query);
 
-        $allRows = $this->approvalRepository->findAllWeek($users);
+        $users = $this->getUsersForApproval();
+        $warningNoUsers = empty($users);
 
-        if ($this->settingsTool->getBooleanConfiguration(ConfigEnum::APPROVAL_HIDE_APPROVED_NY, false)) {
-            $allRows = $this->approvalRepository->filterWeeksNotApproved($allRows);
-        }
-
-        $selectedUsers = $query->getUsers();
-        if (!empty($selectedUsers)) {
-            $selectedUserIds = array_map(fn(User $user) => $user->getId(), $selectedUsers);
-            $allRows = array_filter(
-                $allRows,
-                function ($row) use ($selectedUserIds) {
-                    return in_array($row['userId'], $selectedUserIds);
-                }
-            );
-        }
-
-        $dateRange = $query->getDateRange();
-        if ($dateRange !== null && $dateRange->getBegin() !== null && $dateRange->getEnd() !== null) {
-            $begin = $dateRange->getBegin();
-            $end = $dateRange->getEnd();
-
-            $allRows = array_filter(
-                $allRows,
-                function ($row) use ($begin, $end) {
-                    $weekStart = $row['week']->value;
-                    $weekEnd = (clone $weekStart)->modify('+6 days');
-                    return ($weekStart >= $begin && $weekStart <= $end) ||
-                        ($weekEnd >= $begin && $weekEnd <= $end);
-                }
-            );
+        if ($warningNoUsers) {
+            $users = [$this->getUser()];
         }
 
-        $selectedStatus = $query->getStatus();
-        if (!empty($selectedStatus)) {
-            $allRows = array_filter(
-                $allRows,
-                function ($row) use ($selectedStatus) {
-                    return in_array($row['status'], $selectedStatus);
-                }
-            );
+        $allRows = $this->approvalDataService->fetchAndFilterApprovalRows($query, $users);
+        if ($this->settingsTool->isBreakTimeCheckActive()) {
+            $allRows = $this->approvalDataService->enrichRowsWithErrors($allRows);
         }
-
-        $searchTerm = $query->getSearchTerm();
-        if ($searchTerm !== null && !empty($searchTerm->getSearchTerm())) {
-
-            $searchParts = $searchTerm->getParts();
-
-            $allRows = array_filter(
-                $allRows,
-                function ($row) use ($searchParts) {
-                    foreach ($searchParts as $part) {
-                        $term = mb_strtolower($part->getTerm());
-                        $matchedInRow = false;
-
-                        $userName = mb_strtolower($row['user']);
-                        if (str_contains($userName, $term)) {
-                            $matchedInRow = true;
-                        }
-
-                        $weekLabel = mb_strtolower($row['week']->label ?? '');
-                        if (str_contains($weekLabel, $term)) {
-                            $matchedInRow = true;
-                        }
-
-                        $status = mb_strtolower($row['status']);
-                        if (str_contains($status, $term)) {
-                            $matchedInRow = true;
-                        }
-
-                        if (!$matchedInRow) {
-                            return false;
-                        }
-                    }
-                    return true;
-                }
-            );
-        }
-
         $allRows = $this->sortArrayByQuery($allRows, $query);
 
-        $pastRows = [];
-        $currentRows = [];
-        $futureRows = [];
-        $currentWeek = (new DateTime('now'))->modify('next monday')->modify('-2 week')->format('Y-m-d');
-        $futureWeek = (new DateTime('now'))->modify('next monday')->modify('-1 week')->format('Y-m-d');
-        foreach ($allRows as $row) {
-            if ($row['startDate'] >= $futureWeek) {
-                $futureRows[] = $row;
-            } elseif ($row['startDate'] >= $currentWeek) {
-                $currentRows[] = $row;
-            } else {
-                $pastRows[] = $row;
-            }
-        }
+        [$pastRows, $currentRows, $futureRows] = $this->approvalDataService->categorizeRowsByWeek($allRows);
         $pastRows = $this->approvalRepository->filterPastWeeksNotApproved($pastRows);
 
-        $allRowsDataTable = new DataTable('approval_all_entries', $query);
-        $allRowsDataTable->deactivateConfiguration();
-        $allRowsDataTable->addColumn("user");
-        $allRowsDataTable->addColumn("week");
-        $allRowsDataTable->addColumn("status");
-        $allRowsDataTable->addColumn("actions", ['class' => 'actions alwaysVisible']);
-
-        $allRowsAdapter = new ArrayAdapter($allRows);
-        $allRowsPagination = new Pagination($allRowsAdapter);
-        $allRowsDataTable->setPagination($allRowsPagination);
-        $allRowsDataTable->setSearchForm($form);
+        $weeksSubmitted = $this->approvalDataService->countSubmittedWeeks($allRows);
+        $dataTable = $this->buildDataTable($query, $allRows, $form);
 
         return $this->render('@Approval/to_approve.html.twig', [
             'current_tab' => 'to_approve',
-            'all_rows_datatable' => $allRowsDataTable,
+            'all_rows_datatable' => $dataTable,
             'past_rows' => $pastRows,
             'current_rows' => $currentRows,
             'future_rows' => $futureRows,
+            'weeks_submitted' => $weeksSubmitted,
+            'auto_approve_success' => $request->query->getInt('auto_approve_success', 0),
+            'auto_approve_fail' => $request->query->getInt('auto_approve_fail', 0),
             'warningNoUsers' => $warningNoUsers
         ] + $this->getDefaultTemplateParams($this->settingsTool));
     }
 
+    private function getUsersForApproval(): array
+    {
+        $includeSelf = $this->settingsTool->getConfiguration(ConfigEnum::APPROVAL_TEAMLEAD_SELF_APPROVE_NY) == '1';
+        return $this->getUsers($includeSelf);
+    }
+
+    private function buildDataTable(ApprovalQuery $query, array $rows, FormInterface $form): DataTable
+    {
+        $dataTable = new DataTable('approval_all_entries', $query);
+        $dataTable->deactivateConfiguration();
+        $dataTable->addColumn("user");
+        $dataTable->addColumn("week");
+        $dataTable->addColumn("status");
+        $dataTable->addColumn("actions", ['class' => 'actions alwaysVisible']);
+
+        $adapter = new ArrayAdapter($rows);
+        $pagination = new Pagination($adapter);
+        $dataTable->setPagination($pagination);
+        $dataTable->setSearchForm($form);
+
+        return $dataTable;
+    }
+
     protected function getToolbarForm(ApprovalQuery $query): FormInterface
     {
         return $this->createSearchForm(ApprovalToolbarForm::class, $query, [
@@ -562,22 +490,25 @@ private function getTimesheets(?User $selectedUser, DateTime $start, DateTime $e
             $this->settingsTool->isInConfiguration(ConfigEnum::APPROVAL_BREAKCHECKS_NY) == false or
             $this->settingsTool->getConfiguration(ConfigEnum::APPROVAL_BREAKCHECKS_NY)
         ) {
-            $errors = $this->breakTimeCheckToolGER->checkBreakTime($timesheets);
+            $breakTimeErrors = $this->breakTimeCheckToolGER->checkBreakTimeDetails($timesheets);
+            $errors = $breakTimeErrors['days'];
+            $timesheetErrors = $breakTimeErrors['timesheets'];
         } else {
             $errors = [];
+            $timesheetErrors = [];
         }
 
         return [
             array_reduce(
                 $timesheets,
-                function ($result, Timesheet $timesheet) use ($errors) {
+                function ($result, Timesheet $timesheet) use ($timesheetErrors) {
                     $date = $timesheet->getBegin()->format('Y-m-d');
                     if ($timesheet->getEnd()) {
                         $result[] = [
                             'date' => $date,
                             'begin' => $timesheet->getBegin()->format('H:i'),
                             'end' => $timesheet->getEnd()->format('H:i'),
-                            'error' => \array_key_exists($date, $errors) ? $errors[$date] : [],
+                            'error' => $timesheetErrors[spl_object_id($timesheet)] ?? [],
                             'duration' => $timesheet->getDuration(),
                             'customerName' => $timesheet->getProject()->getCustomer()->getName(),
                             'projectName' => $timesheet->getProject()->getName(),
diff --git a/Controller/WorkingTimeActGERController.php b/Controller/WorkingTimeActGERController.php
new file mode 100644
index 0000000..e2fa763
--- /dev/null
+++ b/Controller/WorkingTimeActGERController.php
@@ -0,0 +1,325 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Controller;
+
+use App\Entity\User;
+use App\Form\Model\DateRange;
+use App\Repository\TimesheetRepository;
+use App\Repository\UserRepository;
+use App\Repository\Query\TimesheetQuery;
+use App\Repository\Query\BaseQuery;
+use App\Utils\SearchTerm;
+use DateTimeInterface;
+use Pagerfanta\Adapter\ArrayAdapter;
+use App\Utils\DataTable;
+use App\Utils\Pagination;
+use DateTime;
+use KimaiPlugin\ApprovalBundle\Toolbox\BreakTimeCheckToolGER;
+use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
+use KimaiPlugin\ApprovalBundle\Toolbox\WorkingTimeActToolGER;
+use KimaiPlugin\ApprovalBundle\Form\Toolbar\WorkingTimeActToolbarForm;
+use KimaiPlugin\ApprovalBundle\Repository\Query\WorkingTimeActQuery;
+use Symfony\Component\Form\FormInterface;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Attribute\Route;
+
+#[Route(path: '/approval')]
+class WorkingTimeActGERController extends BaseApprovalController
+{
+
+    public function __construct(
+        private TimesheetRepository $timesheetRepository,
+        private UserRepository $userRepository,
+        private BreakTimeCheckToolGER $breakTimeCheckToolGER,
+        private WorkingTimeActToolGER $workingTimeActToolGER,
+        private SettingsTool $settingsTool
+    ) {
+    }
+
+    #[Route(path: '/workingtimeactger', name: 'approval_bundle_working_time_act_ger', methods: ['GET', 'POST'])]
+    public function workingTimeActCheck(WorkingTimeActQuery $query, Request $request): Response
+    {
+        if (!$this->isGranted('ROLE_SUPER_ADMIN')) {
+            throw $this->createAccessDeniedException();
+        }
+
+        $form = $this->getToolbarForm($query);
+        if ($this->handleSearch($form, $request)) {
+            return $this->redirectToRoute('approval_bundle_working_time_act_ger');
+        }
+
+        $users = $this->getUsersToProcess($query);
+        $results = $this->processAllUsersCompliance($users, $query);
+        $results = $this->filterBySearchTerm($results, $query->getSearchTerm());
+        $results = $this->sortArrayByQuery($results, $query);
+
+        $dataTable = $this->buildDataTable($query, $results, $form);
+
+        return $this->render('@Approval/working_time_act_ger_check.html.twig', array_merge($this->getDefaultTemplateParams($this->settingsTool), [
+            "current_tab" => "working_time_act_ger_check",
+            "dataTable" => $dataTable,
+        ]));
+    }
+
+    /**
+     * Get the list of users to process for compliance checking
+     *
+     * @param WorkingTimeActQuery $query
+     * @return User[]
+     */
+    private function getUsersToProcess(WorkingTimeActQuery $query): array
+    {
+        return $query->getUsers() ?: $this->userRepository->findAll();
+    }
+
+    /**
+     * Process compliance for all users
+     *
+     * @param User[] $users
+     * @param WorkingTimeActQuery $query
+     * @return array
+     */
+    private function processAllUsersCompliance(array $users, WorkingTimeActQuery $query): array
+    {
+        $results = [];
+        $hasCustomDateRange = $this->hasCustomDateRange($query);
+
+        foreach ($users as $user) {
+            $result = $hasCustomDateRange
+                ? $this->processCustomDateRangeCompliance($user, $query)
+                : $this->processDefaultPeriodsCompliance($user);
+
+            $results[] = $result;
+        }
+
+        return $results;
+    }
+
+    /**
+     * Check if query has a custom date range
+     *
+     * @param WorkingTimeActQuery $query
+     * @return bool
+     */
+    private function hasCustomDateRange(WorkingTimeActQuery $query): bool
+    {
+        return $query->getDateRange()
+            && $query->getDateRange()->getBegin()
+            && $query->getDateRange()->getEnd();
+    }
+
+    /**
+     * Process compliance for custom date range
+     *
+     * @param User $user
+     * @param WorkingTimeActQuery $query
+     * @return array
+     */
+    private function processCustomDateRangeCompliance(User $user, WorkingTimeActQuery $query): array
+    {
+        $periodStart = $query->getDateRange()->getBegin();
+        $periodEnd = $query->getDateRange()->getEnd();
+
+        $timesheets = $this->getTimesheets($user, $periodStart, $periodEnd);
+        $publicHolidayGroupId = $this->getPublicHolidayGroupId($user);
+
+        $complianceResult = $this->workingTimeActToolGER->checkWorkingTimeActToolGERCompliance(
+            $timesheets,
+            $publicHolidayGroupId,
+            $periodStart,
+            $periodEnd
+        );
+
+        return [
+            'user' => $user->getDisplayName(),
+            'average_daterange' => round($complianceResult['average'], 2),
+        ];
+    }
+
+    /**
+     * Process compliance for default periods (6 months and 24 weeks)
+     *
+     * @param User $user
+     * @return array
+     */
+    private function processDefaultPeriodsCompliance(User $user): array
+    {
+        $periodEnd = new DateTime();
+        $periodStart6Months = new DateTime('-6 month');
+        $periodStart24Weeks = new DateTime('-24 week');
+
+        $publicHolidayGroupId = $this->getPublicHolidayGroupId($user);
+
+        // Get timesheets for 6 months (covers both periods)
+        $timesheets6Months = $this->getTimesheets($user, $periodStart6Months, $periodEnd);
+
+        $complianceResult6Months = $this->workingTimeActToolGER->checkWorkingTimeActToolGERCompliance(
+            $timesheets6Months,
+            $publicHolidayGroupId,
+            $periodStart6Months,
+            $periodEnd
+        );
+
+        // Filter timesheets for 24 weeks period
+        $timesheets24Weeks = $this->filterTimesheetsByDate($timesheets6Months, $periodStart24Weeks);
+
+        $complianceResult24Weeks = $this->workingTimeActToolGER->checkWorkingTimeActToolGERCompliance(
+            $timesheets24Weeks,
+            $publicHolidayGroupId,
+            $periodStart24Weeks,
+            $periodEnd
+        );
+
+        return [
+            'user' => $user->getDisplayName(),
+            'average_6months' => round($complianceResult6Months['average'], 2),
+            'average_24weeks' => round($complianceResult24Weeks['average'], 2),
+            'compliance' => $complianceResult6Months['compliance'] && $complianceResult24Weeks['compliance'],
+        ];
+    }
+
+    /**
+     * Get public holiday group ID for a user
+     *
+     * @param User $user
+     * @return int|null
+     */
+    private function getPublicHolidayGroupId(User $user): ?int
+    {
+        return $user->getPublicHolidayGroup() ? (int) $user->getPublicHolidayGroup() : null;
+    }
+
+    /**
+     * Filter timesheets by minimum date
+     *
+     * @param array $timesheets
+     * @param DateTime $minDate
+     * @return array
+     */
+    private function filterTimesheetsByDate(array $timesheets, DateTime $minDate): array
+    {
+        return array_filter($timesheets, function ($timesheet) use ($minDate) {
+            return $timesheet->getBegin() >= $minDate;
+        });
+    }
+
+    private function getTimesheets(?User $selectedUser, DateTime $start, DateTime $end): array
+    {
+        $timesheetQuery = new TimesheetQuery();
+        $timesheetQuery->setUser($selectedUser);
+        $dateRange = new DateRange();
+        $dateRange->setBegin($start);
+        $dateRange->setEnd($end);
+        $timesheetQuery->setDateRange($dateRange);
+        $timesheetQuery->setOrderBy('date');
+        $timesheetQuery->setOrderBy('begin');
+        $timesheetQuery->setOrder(BaseQuery::ORDER_ASC);
+
+        return $this->timesheetRepository->getTimesheetsForQuery($timesheetQuery);
+
+    }
+
+    /**
+     * Check ArbZG compliance for timesheets
+     */
+    /**
+     * Build DataTable for Working Time Act compliance results
+     */
+    private function buildDataTable(WorkingTimeActQuery $query, array $rows, FormInterface $form): DataTable
+    {
+        $dataTable = new DataTable('working_time_act_check', $query);
+        $dataTable->deactivateConfiguration();
+        $dataTable->addColumn("user", ['label' => 'label.user']);
+
+        if ($query->getDateRange() && $query->getDateRange()->getBegin() && $query->getDateRange()->getEnd()) {
+            $dataTable->addColumn("label.average_daterange", ['label' => 'label.average_daterange']);
+        } else {
+            $dataTable->addColumn("label.average_6months", ['label' => 'label.average_6months']);
+            $dataTable->addColumn("label.average_24weeks", ['label' => 'label.average_24']);
+            $dataTable->addColumn("label.compliance", ['label' => 'label.compliance', 'type' => 'boolean']);
+        }
+
+        $adapter = new ArrayAdapter($rows);
+        $pagination = new Pagination($adapter);
+        $dataTable->setPagination($pagination);
+        $dataTable->setSearchForm($form);
+
+        return $dataTable;
+    }
+
+    protected function getToolbarForm(WorkingTimeActQuery $query): FormInterface
+    {
+        return $this->createSearchForm(WorkingTimeActToolbarForm::class, $query, [
+            'action' => $this->generateUrl('approval_bundle_working_time_act_ger', [
+                'page' => $query->getPage(),
+            ]),
+            'timezone' => $this->getDateTimeFactory()->getTimezone()->getName(),
+        ]);
+    }
+
+    private function filterBySearchTerm(array $rows, ?SearchTerm $searchTerm): array
+    {
+        if ($searchTerm === null || empty($searchTerm->getSearchTerm())) {
+            return $rows;
+        }
+
+        $searchParts = $searchTerm->getParts();
+
+        return array_filter($rows, function ($row) use ($searchParts) {
+            foreach ($searchParts as $part) {
+                if (!$this->rowMatchesSearchTerm($row, mb_strtolower($part->getTerm()))) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+
+    private function rowMatchesSearchTerm(array $row, string $term): bool
+    {
+        $searchableFields = [
+            mb_strtolower($row['user'] ?? ''),
+            (string) ($row['average_6months'] ?? ''),
+            (string) ($row['average_24weeks'] ?? ''),
+        ];
+
+        foreach ($searchableFields as $field) {
+            if (str_contains($field, $term)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function sortArrayByQuery(array $rows, WorkingTimeActQuery $query): array
+    {
+        $orderBy = $query->getOrderBy();
+        $order = $query->getOrder();
+
+        if (!$orderBy || !in_array($orderBy, WorkingTimeActQuery::ORDER_ALLOWED, true)) {
+            return $rows;
+        }
+
+        usort($rows, function ($a, $b) use ($orderBy, $order) {
+            $valueA = $a[$orderBy] ?? null;
+            $valueB = $b[$orderBy] ?? null;
+
+            if (is_string($valueA) || is_string($valueB)) {
+                $valueA = mb_strtolower((string) $valueA);
+                $valueB = mb_strtolower((string) $valueB);
+            }
+
+            if ($valueA == $valueB) {
+                return 0;
+            }
+
+            $result = ($valueA < $valueB) ? -1 : 1;
+            return $order === BaseQuery::ORDER_DESC ? -$result : $result;
+        });
+
+        return $rows;
+    }
+
+}
\ No newline at end of file
diff --git a/Form/Toolbar/WorkingTimeActToolbarForm.php b/Form/Toolbar/WorkingTimeActToolbarForm.php
new file mode 100644
index 0000000..dedec96
--- /dev/null
+++ b/Form/Toolbar/WorkingTimeActToolbarForm.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Form\Toolbar;
+
+use App\Form\Toolbar\ToolbarFormTrait;
+use KimaiPlugin\ApprovalBundle\Repository\Query\WorkingTimeActQuery;
+use Symfony\Component\Form\AbstractType;
+use Symfony\Component\Form\FormBuilderInterface;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+final class WorkingTimeActToolbarForm extends AbstractType
+{
+    use ToolbarFormTrait;
+
+    public function buildForm(FormBuilderInterface $builder, array $options): void
+    {
+        $this->addSearchTermInputField($builder);
+
+        $this->addDateRange($builder, ['timezone' => $options['timezone']]);
+
+        $this->addUsersChoice($builder);
+
+        $this->addHiddenPagination($builder);
+
+        $query = $options['data'];
+
+        if ($query instanceof WorkingTimeActQuery) {
+            $this->addOrder($builder);
+            $this->addOrderBy($builder, $query->getAllowedOrderColumns());
+        }
+    }
+
+    public function configureOptions(OptionsResolver $resolver): void
+    {
+        $resolver->setDefaults([
+            'data_class' => WorkingTimeActQuery::class,
+            'csrf_protection' => false,
+            'timezone' => date_default_timezone_get(),
+        ]);
+    }
+}
diff --git a/Repository/ApprovalRepository.php b/Repository/ApprovalRepository.php
index 5e8b9cf..a1aaeb0 100644
--- a/Repository/ApprovalRepository.php
+++ b/Repository/ApprovalRepository.php
@@ -19,6 +19,7 @@
 use KimaiPlugin\ApprovalBundle\Entity\ApprovalHistory;
 use KimaiPlugin\ApprovalBundle\Entity\ApprovalStatus;
 use KimaiPlugin\ApprovalBundle\Enumeration\ConfigEnum;
+use KimaiPlugin\ApprovalBundle\Repository\Query\ApprovalQuery;
 use KimaiPlugin\ApprovalBundle\Settings\ApprovalSettingsInterface;
 use KimaiPlugin\ApprovalBundle\Toolbox\Formatting;
 use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
@@ -782,6 +783,109 @@ public function getUserApprovals(?array $users, $startDate = null)
         return $parseToViewArray;
     }
 
+    public function getUserApprovalsFiltered(?array $users, ApprovalQuery $query, $startDate = null)
+    {
+        if (count($users) == 0) {
+            return [];
+        }
+
+        $usersId = array_map(function ($user) {
+            return $user->getId();
+        }, $users);
+
+        $approval_workflow_start = $this->settingsTool->getConfiguration(ConfigEnum::APPROVAL_WORKFLOW_START);
+        if ($approval_workflow_start == '') {
+            $approval_workflow_start = '0000-01-01';
+        } else {
+            $approval_workflow_start = (new DateTime($approval_workflow_start))->modify('-7 day')->format('Y-m-d');
+        }
+
+        if ($startDate !== null) {
+            $start = $startDate;
+        } else {
+            $start = $approval_workflow_start;
+        }
+
+        $dateRangeStart = $query->getBegin() ?? null;
+        $dateRangeEnd = $query->getEnd() ?? null;
+        $searchTerm = $query->getSearchTerm();
+
+
+        $em = $this->getEntityManager();
+        $qb = $em->createQueryBuilder()
+            ->select('ap')
+            ->from(Approval::class, 'ap')
+            ->join('ap.user', 'u')
+            ->join('ap.history', 'ah')
+            ->join('ah.status', 'ast')
+            ->andWhere($em->getExpressionBuilder()->in('u.id', $usersId))
+            ->andWhere("ast.name = '" . ApprovalStatus::SUBMITTED . "'")
+            ->andWhere('ap.startDate >= :begin')
+            ->setParameter('begin', $start);
+
+        if ($dateRangeStart !== null) {
+            $qb->andWhere('ap.startDate >= :dateRangeStart')
+                ->setParameter('dateRangeStart', $dateRangeStart);
+        }
+
+        if ($dateRangeEnd !== null) {
+            $qb->andWhere('ap.endDate <= :dateRangeEnd')
+                ->setParameter('dateRangeEnd', $dateRangeEnd);
+        }
+
+        $approvedListFiltered = $qb
+            ->getQuery()
+            ->getResult();
+
+        $this->parseHistoryToOneElement($approvedListFiltered);
+
+        if ($searchTerm !== null && !empty($searchTerm->getSearchTerm())) {
+            $searchParts = $searchTerm->getParts();
+            $approvedListFiltered = array_filter(
+                $approvedListFiltered,
+                function ($item) use ($searchParts) {
+                    foreach ($searchParts as $part) {
+                        $term = mb_strtolower($part->getTerm());
+                        $matchedInItem = false;
+
+                        $userName = mb_strtolower($item->getUser()->getUsername() ?? '');
+                        if (str_contains($userName, $term)) {
+                            $matchedInItem = true;
+                        }
+
+                        $userAlias = mb_strtolower($item->getUser()->getAlias() ?? '');
+                        if (str_contains($userAlias, $term)) {
+                            $matchedInItem = true;
+                        }
+
+                        $weekLabel = mb_strtolower($this->formatting->parseDate($item->getStartDate()) ?? '');
+                        if (str_contains($weekLabel, $term)) {
+                            $matchedInItem = true;
+                        }
+
+                        if (!$matchedInItem) {
+                            return false;
+                        }
+
+                    }
+                    return true;
+                }
+            );
+        }
+        $approvedListFiltered = array_filter(
+            $approvedListFiltered,
+            function ($item) {
+                $status = mb_strtolower($item->getHistory()[0]->getStatus()->getName() ?? '');
+                if ($status === mb_strtolower(ApprovalStatus::SUBMITTED)) {
+                    return true;
+                }
+                return false;
+            }
+        );
+
+        return $approvedListFiltered;
+    }
+
     private function getLastHistory(Approval $item)
     {
         $history = $item->getHistory();
@@ -821,7 +925,6 @@ public function getNextApproveWeek(User $user): ?string
         if (empty($allRows)) {
             return null;
         }
-
         // Otherwise, when there are $allRows, get the one which would be next (located in the future)
         $prevWeekDay = end($allRows)['startDate'];
         $prev = strtotime($prevWeekDay . ' + 7 days');
@@ -832,6 +935,36 @@ public function getNextApproveWeek(User $user): ?string
         return date('Y-m-d', $prev);
     }
 
+    /**
+     * @param array<int> $userIds
+     * @return Approval[]
+     */
+    public function findApprovedForUsersAndDateRange(array $userIds, \DateTimeInterface $begin, \DateTimeInterface $end): array
+    {
+        if ($userIds === []) {
+            return [];
+        }
+
+        $em = $this->getEntityManager();
+        $qb = $em->createQueryBuilder()
+            ->select('ap')
+            ->from(Approval::class, 'ap')
+            ->join('ap.user', 'u')
+            ->join('ap.history', 'ah')
+            ->join('ah.status', 'ast')
+            ->andWhere($em->getExpressionBuilder()->in('u.id', ':userIds'))
+            ->andWhere('ap.startDate <= :end')
+            ->andWhere('ap.endDate >= :begin')
+            ->andWhere('ah.date = (SELECT MAX(ah2.date) FROM ' . ApprovalHistory::class . ' ah2 WHERE ah2.approval = ap)')
+            ->andWhere('ast.name = :status')
+            ->setParameter('userIds', $userIds)
+            ->setParameter('begin', $begin->format('Y-m-d'))
+            ->setParameter('end', $end->format('Y-m-d'))
+            ->setParameter('status', ApprovalStatus::APPROVED);
+
+        return $qb->getQuery()->getResult();
+    }
+
     public function updateExpectedActualDurationForUser(User $user)
     {
         $approvals = $this->findBy(['user' => $user]);
diff --git a/Repository/Query/ApprovalQuery.php b/Repository/Query/ApprovalQuery.php
index d594a22..edb2536 100644
--- a/Repository/Query/ApprovalQuery.php
+++ b/Repository/Query/ApprovalQuery.php
@@ -2,6 +2,7 @@
 namespace KimaiPlugin\ApprovalBundle\Repository\Query;
 
 use App\Entity\User;
+use App\Form\Model\DateRange;
 use App\Repository\Query\BaseQuery;
 use App\Repository\Query\DateRangeTrait;
 use App\Repository\Query\DateRangeInterface;
@@ -14,7 +15,7 @@ class ApprovalQuery extends BaseQuery implements DateRangeInterface
     /**
      * @var array<User>
      */
-    public array $users = [];
+    private array $users = [];
     private array $weeks = [];
     private array $statuses = [];
 
@@ -26,6 +27,8 @@ public function __construct()
         ]);
 
         $this->setAllowedOrderColumns(self::APPROVAL_ORDER_ALLOWED);
+
+        $this->dateRange = new DateRange();
     }
 
     public function getStatus(): array
@@ -45,4 +48,9 @@ public function getUsers(): array
     {
         return array_values($this->users);
     }
+
+    public function setUsers(array $users): void
+    {
+        $this->users = $users;
+    }
 }
\ No newline at end of file
diff --git a/Repository/Query/WorkingTimeActQuery.php b/Repository/Query/WorkingTimeActQuery.php
new file mode 100644
index 0000000..1da1c47
--- /dev/null
+++ b/Repository/Query/WorkingTimeActQuery.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Repository\Query;
+
+use App\Repository\Query\BaseQuery;
+use App\Repository\Query\DateRangeInterface;
+use App\Repository\Query\DateRangeTrait;
+
+
+class WorkingTimeActQuery extends BaseQuery implements DateRangeInterface
+{
+    use DateRangeTrait;
+    public const ORDER_ALLOWED = ['user', 'average_6months', 'average_24weeks'];
+
+    /**
+     * @var array<User>
+     */
+    private array $users = [];
+
+    public function __construct()
+    {
+        $this->setDefaults([
+            'order' => self::ORDER_ASC,
+            'orderBy' => 'user',
+        ]);
+
+        $this->setAllowedOrderColumns(self::ORDER_ALLOWED);
+    }
+
+    /**
+     * @return User[]
+     */
+    public function getUsers(): array
+    {
+        return array_values($this->users);
+    }
+
+    public function setUsers(array $users): void
+    {
+        $this->users = $users;
+    }
+}
diff --git a/Resources/translations/messages.de.xlf b/Resources/translations/messages.de.xlf
index 9558846..5168773 100644
--- a/Resources/translations/messages.de.xlf
+++ b/Resources/translations/messages.de.xlf
@@ -126,6 +126,18 @@
         <source>stats.duration_actual</source>
         <target>Erfasste Dauer</target>
       </trans-unit>
+      <trans-unit id="xK9mL2pQ" resname="table.auto_approve_confirm">
+        <source>table.auto_approve_confirm</source>
+        <target>Möchten Sie %count% Wochen automatisch genehmigen?</target>
+      </trans-unit>
+      <trans-unit id="R7kLm2Qf" resname="table.auto_approve_result">
+        <source>table.auto_approve_result</source>
+        <target>%success% Wochen automatisch genehmigt, %fail% fehlgeschlagen.</target>
+      </trans-unit>
+      <trans-unit id="aB3cD_eF" resname="table.auto_approve">
+        <source>table.auto_approve</source>
+        <target>Automatische Genehmigung</target>
+      </trans-unit>
       <trans-unit id="YDDLiv4" resname="table.past_weeks">
         <source>table.past_weeks</source>
         <target>Vergangene Wochen</target>
@@ -138,6 +150,30 @@
         <source>table.future_week</source>
         <target>Kommende Wochen</target>
       </trans-unit>
+      <trans-unit id="Qx7pLmA2" resname="table.has_errors_tooltip">
+        <source>table.has_errors_tooltip</source>
+        <target>Hat Errors</target>
+      </trans-unit>
+      <trans-unit id="pQ8mNx4" resname="menu.working_time_act_ger_check">
+        <source>menu.working_time_act_ger_check</source>
+        <target>Arbeitszeitgesetz §3 Check</target>
+      </trans-unit>
+      <trans-unit id="nR7jVqW" resname="label.compliance">
+        <source>label.compliance</source>
+        <target>Einhaltung</target>
+      </trans-unit>
+      <trans-unit id="vK2rTyL" resname="label.average_6months">
+        <source>label.average_6months</source>
+        <target>Durchschnitt 6 Monate</target>
+      </trans-unit>
+      <trans-unit id="hB9wXsF" resname="label.average_24weeks">
+        <source>label.average_24weeks</source>
+        <target>Durchschnitt 24 Wochen</target>
+      </trans-unit>
+      <trans-unit id="zM3cDgP" resname="label.average_daterange">
+        <source>label.average_daterange</source>
+        <target>Durchschnitt Zeitraum</target>
+      </trans-unit>
       <trans-unit id="oTr3M.5" resname="table.approve_user">
         <source>table.approve_user</source>
         <target>Benutzer</target>
diff --git a/Resources/translations/messages.en.xlf b/Resources/translations/messages.en.xlf
index 9b84154..498972d 100644
--- a/Resources/translations/messages.en.xlf
+++ b/Resources/translations/messages.en.xlf
@@ -126,6 +126,18 @@
         <source>stats.duration_actual</source>
         <target>Actual duration</target>
       </trans-unit>
+      <trans-unit id="aB3cD_eF" resname="table.auto_approve">
+        <source>table.auto_approve</source>
+        <target>Auto approval</target>
+      </trans-unit>
+      <trans-unit id="xK9mL2pQ" resname="table.auto_approve_confirm">
+        <source>table.auto_approve_confirm</source>
+        <target>Do you want to automatically approve %count% weeks?</target>
+      </trans-unit>
+      <trans-unit id="R7kLm2Qf" resname="table.auto_approve_result">
+        <source>table.auto_approve_result</source>
+        <target>%success% weeks automatically approved, %fail% failed.</target>
+      </trans-unit>
       <trans-unit id="YDDLiv4" resname="table.past_weeks">
         <source>table.past_weeks</source>
         <target>Past weeks</target>
@@ -138,6 +150,30 @@
         <source>table.future_week</source>
         <target>Upcoming weeks</target>
       </trans-unit>
+      <trans-unit id="Qx7pLmA2" resname="table.has_errors_tooltip">
+        <source>table.has_errors_tooltip</source>
+        <target>Has errors</target>
+      </trans-unit>
+      <trans-unit id="pQ8mNx4" resname="menu.working_time_act_ger_check">
+        <source>menu.working_time_act_ger_check</source>
+        <target>Working time act §3 Check</target>
+      </trans-unit>
+      <trans-unit id="nR7jVqW" resname="label.compliance">
+        <source>label.compliance</source>
+        <target>Compliance</target>
+      </trans-unit>
+      <trans-unit id="vK2rTyL" resname="label.average_6months">
+        <source>label.average_6months</source>
+        <target>Average 6 months</target>
+      </trans-unit>
+      <trans-unit id="hB9wXsF" resname="label.average_24weeks">
+        <source>label.average_24weeks</source>
+        <target>Average 24 weeks</target>
+      </trans-unit>
+      <trans-unit id="zM3cDgP" resname="label.average_daterange">
+        <source>label.average_daterange</source>
+        <target>Average Daterange</target>
+      </trans-unit>
       <trans-unit id="oTr3M.5" resname="table.approve_user">
         <source>table.approve_user</source>
         <target>User</target>
diff --git a/Resources/translations/messages.hr.xlf b/Resources/translations/messages.hr.xlf
index 216bf17..77d977e 100644
--- a/Resources/translations/messages.hr.xlf
+++ b/Resources/translations/messages.hr.xlf
@@ -122,6 +122,18 @@
         <source>stats.duration_actual</source>
         <target>Stvarno trajanje</target>
       </trans-unit>
+      <trans-unit id="aB3cD_eF" resname="table.auto_approve">
+        <source>table.auto_approve</source>
+        <target>Automatsko odobrenje</target>
+      </trans-unit>
+      <trans-unit id="xK9mL2pQ" resname="table.auto_approve_confirm">
+        <source>table.auto_approve_confirm</source>
+        <target>Želite li automatski odobriti %count% tjedana?</target>
+      </trans-unit>
+      <trans-unit id="R7kLm2Qf" resname="table.auto_approve_result">
+        <source>table.auto_approve_result</source>
+        <target>%success% tjedana automatski odobreno, %fail% neuspješno.</target>
+      </trans-unit>
       <trans-unit id="YDDLiv4" resname="table.past_weeks">
         <source>table.past_weeks</source>
         <target>Prošli tjedan</target>
@@ -134,6 +146,30 @@
         <source>table.future_week</source>
         <target>Nadolazećih tjedana</target>
       </trans-unit>
+      <trans-unit id="Qx7pLmA2" resname="table.has_errors_tooltip">
+        <source>table.has_errors_tooltip</source>
+        <target>Ima greške</target>
+      </trans-unit>
+      <trans-unit id="pQ8mNx4" resname="menu.working_time_act_ger_check">
+        <source>menu.working_time_act_ger_check</source>
+        <target>Provjera članka 3 Zakona o radnom vremenu</target>
+      </trans-unit>
+      <trans-unit id="nR7jVqW" resname="label.compliance">
+        <source>label.compliance</source>
+        <target>Usklađenost</target>
+      </trans-unit>
+      <trans-unit id="vK2rTyL" resname="label.average_6months">
+        <source>label.average_6months</source>
+        <target>Prosječno 6 mjeseci</target>
+      </trans-unit>
+      <trans-unit id="hB9wXsF" resname="label.average_24weeks">
+        <source>label.average_24weeks</source>
+        <target>Prosječno 24 tjedna</target>
+      </trans-unit>
+      <trans-unit id="zM3cDgP" resname="label.average_daterange">
+        <source>label.average_daterange</source>
+        <target>Prosječni raspon datuma</target>
+      </trans-unit>
       <trans-unit id="oTr3M.5" resname="table.approve_user">
         <source>table.approve_user</source>
         <target>Korisnik</target>
diff --git a/Resources/views/navigation.html.twig b/Resources/views/navigation.html.twig
index 1aa3002..b1ebba6 100644
--- a/Resources/views/navigation.html.twig
+++ b/Resources/views/navigation.html.twig
@@ -37,4 +37,11 @@
             </a>
         </li>
     {% endif %}
+    {% if showWorkingTimeActCheckGER %}
+        <li class="nav-item">
+            <a class="nav-link{% if current_tab == "working_time_act_ger_check" %} active{% endif %}" href="{{ path('approval_bundle_working_time_act_ger') }}">
+                {{ 'menu.working_time_act_ger_check' |trans }}
+            </a>
+        </li>
+    {% endif %}
 </ul>
diff --git a/Resources/views/report_by_user.html.twig b/Resources/views/report_by_user.html.twig
index d7726b3..d295729 100644
--- a/Resources/views/report_by_user.html.twig
+++ b/Resources/views/report_by_user.html.twig
@@ -4,6 +4,10 @@
 
 {% block report_title %}{{ report_title|trans }}{% endblock %}
 
+{% set lastStatus = approve|last %}
+{% set penultimateStatus = approve|length > 1 ? approve[approve|length - 2] : null %}
+
+
 {% block report %}
     {% if approvePreviousWeeksMessage and approvePreviousWeeksMessage < (current | date_format('Y-m-d')) %}
         {{ widgets.callout('danger', 'warning.add_to_approve_previous_weeks'|trans) }}
@@ -18,7 +22,11 @@
     {% endif %}
 
     <div class="card mb-4">
-        <div class="card-body {{ status_color_class(status) }}">
+        <div class="card-body {%- if penultimateStatus and penultimateStatus['status'] == 'denied' and lastStatus and lastStatus['status'] == 'not_submitted' %}
+            bg-danger
+        {%- else %}
+            {{ status_color_class(status) }}
+        {%- endif %}">
             {{ form_start(form, {'attr': {'class': 'form-inline', 'id': 'user_approval_form'}}) }}
             <div class="btn-list w-100">
             {% if form.date is defined %}
@@ -44,7 +52,7 @@
                     </a>
                 {% endif %}
                     {% if (status == 'submitted') and (user.id != currentUser or canManageHimself) %}
-                    <a href="{{ path('approve',{'approveId':approveId,'user':user.id,'date':current|date('Y-m-d')}) }}" class="btn btn-default btn-create" title="{{ 'tooltip.approve'|trans }}">
+                    <a id="approveButton" href="{{ path('approve',{'approveId':approveId,'user':user.id,'date':current|date('Y-m-d')}) }}" class="btn btn-default btn-create" title="{{ 'tooltip.approve'|trans }}">
                         <i class="fa fa-1x fa-check-circle"></i>
                     </a>
                     <a id="deniedButton" class="btn btn-default btn-create closeModal" title="{{ 'tooltip.reject'|trans }}" data-bs-toggle="modal" data-bs-target="#deniedMessage">
@@ -234,6 +242,11 @@
             </table>
         </div>
     {% endif %}
+    <div id="loadingOverlay" style="display: none; position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: rgba(0, 0, 0, 0.5); z-index: 9999; justify-content: center; align-items: center;">
+         <div class="spinner-border text-success" role="status" style="width: 3rem; height: 3rem; border-width: 0.4rem;">
+            <span class="visually-hidden">Loading...</span>
+        </div>
+    </div>
 {% endblock %}
 
 {% block javascripts %}
@@ -247,6 +260,14 @@
             });
         }
 
+        const approveButton = document.getElementById("approveButton");
+        if (approveButton !== null) {
+            approveButton.addEventListener("click", (event) => {
+                const loadingOverlay = document.getElementById("loadingOverlay");
+                loadingOverlay.style.display = "flex";
+            });
+        }
+
         const undoButton = document.getElementById("undoButton");
         if (undoButton !== null) {
             undoButton.addEventListener("click", () => {
diff --git a/Resources/views/to_approve.html.twig b/Resources/views/to_approve.html.twig
index 6f63462..a920eb8 100644
--- a/Resources/views/to_approve.html.twig
+++ b/Resources/views/to_approve.html.twig
@@ -15,11 +15,61 @@
         tr.table-section-header h3 {
             margin: 0;
         }
+
+        #to-approve-actions {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 10px;
+        }
     </style>
 {% endblock %}
 
 {% block report %}
-    {{ tables.actions(all_rows_datatable) }}
+    <div id="to-approve-actions">
+        {{ tables.actions(all_rows_datatable) }}
+        <button class="btn btn-default" id="auto-approve-button" data-bs-toggle="modal" data-bs-target="#autoApproveConfirmationMessage">{{ 'table.auto_approve'|trans}}</button>
+    </div>
+    <div class="modal fade" id="autoApproveConfirmationMessage" tabindex="-1" aria-labelledby="autoApproveConfirmationLabel" aria-hidden="true">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title" id="autoApproveConfirmationLabel">{{ 'table.auto_approve'|trans}}</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <div class="modal-body">
+                    <p>{{ 'table.auto_approve_confirm'|trans({'%count%': weeks_submitted}) }}</p>
+                </div>
+                <div class="modal-footer">
+                    <a href="{{path('auto_approve')}}" class="btn btn-primary pull-left" id="autoApproveLink">{{ 'action.save'|trans }}</a>
+                    <button type="button" class="btn btn-cancel" data-bs-dismiss="modal">{{ 'action.close'|trans }}</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div class="modal fade" id="autoApproveResultMessage" tabindex="-1" aria-labelledby="autoApproveResultLabel" aria-hidden="true">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title" id="autoApproveResultLabel">{{ 'table.auto_approve'|trans}}</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <div class="modal-body">
+                    <p>
+                        {{ 'table.auto_approve_result'|trans({
+                            '%success%': auto_approve_success,
+                            '%fail%': auto_approve_fail
+                        }) }}
+                    </p>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-cancel" data-bs-dismiss="modal">{{ 'action.close'|trans }}</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
     {{ tables.header(all_rows_datatable) }}
 
     {% set sortedColumns = all_rows_datatable.sortedColumnNames %}
@@ -71,6 +121,12 @@
 {% block datatable_column %}
     <td class="{{ tables.class(all_rows_datatable, column) }}">
     {% if column == 'user' %}
+        {% if entry['hasErrors'] is defined and entry['hasErrors'] %}
+        <span class="d-inline-block" tabindex="0" data-toggle="tooltip"
+      title="{{ 'table.has_errors_tooltip'|trans }}">
+            <i class="fa fa-1x fa-exclamation-circle" style="color: red"></i>
+        </span>
+        {% endif %}
         {{ entry['user'] }}
     {% elseif column == 'week' %}
         {{ entry['week'].label }}
@@ -126,5 +182,38 @@
                 document.dispatchEvent(new Event('filter-change'));
             }
         }, true);
+
+        document.addEventListener('DOMContentLoaded', () => {
+            const urlParams = new URLSearchParams(window.location.search);
+            const modal = document.getElementById('autoApproveResultMessage');
+            const closeBtns = modal?.querySelectorAll('[data-bs-dismiss="modal"]');
+
+            const hasResult = urlParams.has('auto_approve_success') && urlParams.has('auto_approve_fail');
+
+
+            if (hasResult && modal) {
+                modal.classList.add('show');
+                modal.setAttribute('aria-modal', 'true');
+                modal.setAttribute('aria-hidden', 'false');
+                modal.style.display = 'block';
+                document.body.classList.add('modal-open');
+
+                urlParams.delete('auto_approve_success');
+                urlParams.delete('auto_approve_fail');
+                const newUrl = `${location.pathname}?${urlParams.toString()}`;
+                history.replaceState({}, '', newUrl);
+            }
+
+            closeBtns?.forEach(btn => btn.addEventListener('click', () => {
+                if (document.activeElement) {
+                    document.activeElement.blur();
+                }
+                modal.classList.remove('show');
+                modal.removeAttribute('aria-modal');
+                modal.setAttribute('aria-hidden', 'true');
+                modal.style.display = 'none';
+                document.body.classList.remove('modal-open');
+            }));
+        });
     </script>
 {% endblock %}
\ No newline at end of file
diff --git a/Resources/views/working_time_act_ger_check.html.twig b/Resources/views/working_time_act_ger_check.html.twig
new file mode 100644
index 0000000..abdea0d
--- /dev/null
+++ b/Resources/views/working_time_act_ger_check.html.twig
@@ -0,0 +1,91 @@
+{% extends '@Approval/layout.html.twig' %}
+{% from '@Approval/macros.html.twig' import status_color_class %}
+{% import "macros/datatables.html.twig" as tables %}
+
+{% block report_title %}{{ report_title|trans }}{% endblock %}
+
+
+{% block report %}
+     
+     {{ tables.actions(dataTable) }}
+
+     {{ tables.header(dataTable) }}
+
+     {% set sortedColumns = dataTable.sortedColumnNames %}
+
+     {% for entry in dataTable %}
+          <tr>
+               {% for column, data in sortedColumns %}
+                    <td class="{{ tables.class(dataTable, column) }}">
+                         {% if column == 'user' %}
+                              {{ entry['user'] }}
+                         {% elseif column == 'label.average_6months' and entry['average_6months'] is defined %}
+                              {{ entry['average_6months'] }}
+                         {% elseif column == 'label.average_24weeks' and entry['average_24weeks'] is defined %}
+                              {{ entry['average_24weeks'] }}
+                         {% elseif column == 'label.average_daterange' and entry['average_daterange'] is defined %}
+                              {{ entry['average_daterange'] }}
+                         {% elseif column == 'label.compliance' and entry['compliance'] is defined %}
+                              {% if entry['compliance'] %}
+                                   <span class="d-inline-block" tabindex="0" data-toggle="tooltip" title="{{ 'compliance.yes'|trans }}">
+                                        <i class="fa fa-check-circle text-success"></i>
+                                   </span>
+                              {% else %}
+                                   <span class="d-inline-block" tabindex="0" data-toggle="tooltip" title="{{ 'compliance.no'|trans }}">
+                                        <i class="fa fa-times-circle text-danger"></i>
+                                   </span>
+                              {% endif %}
+                         {% endif %}
+                    </td>
+               {% endfor %}
+          </tr>
+     {% endfor %}
+
+     
+     {{ tables.footer(dataTable) }}
+
+{% endblock %}
+
+{% block javascripts %}
+   {{ parent() }}
+    <script>
+        let kimaiInstance = null;
+        
+        document.addEventListener('kimai.initialized', function(e) {
+            kimaiInstance = e.detail.kimai;
+        });
+    
+        document.addEventListener('kimai.reloadedContent', function() {
+            if (kimaiInstance) {
+                const formSelectPlugin = kimaiInstance.getPlugin('form-select');
+                const searchForm = document.querySelector('form.searchform');
+                
+                if (formSelectPlugin && searchForm) {
+                    formSelectPlugin.activateForm(searchForm);
+                }
+            }
+        });
+
+        // Override Kimai's default DESC sorting behavior
+        document.body.addEventListener('click', (event) => {
+            if (!event.target.matches('th.sortable')) {
+                return;
+            }
+            const isSorted = event.target.classList.contains('sorting_asc') || 
+                           event.target.classList.contains('sorting_desc');
+            if (!isSorted) {
+                event.stopImmediatePropagation();
+                
+                const orderBy = event.target.dataset['order'];
+                const formSelector = 'form.searchform';
+                
+                document.querySelector(formSelector + ' #orderBy').value = orderBy;
+                document.querySelector(formSelector + ' #order').value = 'ASC';
+                
+                document.querySelector(formSelector + ' #orderBy').dispatchEvent(new Event('change'));
+                document.querySelector(formSelector + ' #order').dispatchEvent(new Event('change'));
+                document.dispatchEvent(new Event('filter-change'));
+            }
+        }, true);
+    </script>
+{% endblock %}
diff --git a/Service/ApprovalDataService.php b/Service/ApprovalDataService.php
new file mode 100644
index 0000000..14a51c7
--- /dev/null
+++ b/Service/ApprovalDataService.php
@@ -0,0 +1,184 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Service;
+
+use App\Entity\User;
+use App\Form\Model\DateRange;
+use App\Repository\Query\BaseQuery;
+use App\Repository\Query\TimesheetQuery;
+use App\Repository\TimesheetRepository;
+use App\Repository\UserRepository;
+use DateTime;
+use KimaiPlugin\ApprovalBundle\Enumeration\ConfigEnum;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalRepository;
+use KimaiPlugin\ApprovalBundle\Repository\Query\ApprovalQuery;
+use KimaiPlugin\ApprovalBundle\Toolbox\BreakTimeCheckToolGER;
+use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
+
+class ApprovalDataService
+{
+    public function __construct(
+        private ApprovalRepository $approvalRepository,
+        private UserRepository $userRepository,
+        private TimesheetRepository $timesheetRepository,
+        private BreakTimeCheckToolGER $breakTimeCheckToolGER,
+        private SettingsTool $settingsTool
+    ) {
+    }
+
+    public function fetchAndFilterApprovalRows(ApprovalQuery $query, array $users): array
+    {
+        $rows = $this->approvalRepository->findAllWeek($users);
+
+        if ($this->settingsTool->getBooleanConfiguration(ConfigEnum::APPROVAL_HIDE_APPROVED_NY, false)) {
+            $rows = $this->approvalRepository->filterWeeksNotApproved($rows);
+        }
+
+        $rows = $this->filterByUsers($rows, $query->getUsers());
+        $rows = $this->filterByDateRange($rows, $query->getDateRange());
+        $rows = $this->filterByStatus($rows, $query->getStatus());
+        $rows = $this->filterBySearchTerm($rows, $query->getSearchTerm());
+
+        return $rows;
+    }
+
+    public function enrichRowsWithErrors(array $rows): array
+    {
+        foreach ($rows as &$row) {
+            $timesheets = $this->getTimesheetsForRow($row);
+            $errors = $this->getBreakTimeErrors($timesheets);
+            $row['hasErrors'] = !empty(array_filter($errors));
+        }
+        return $rows;
+    }
+
+    public function categorizeRowsByWeek(array $rows): array
+    {
+        $currentWeek = (new DateTime('now'))->modify('next monday')->modify('-1 week')->format('Y-m-d');
+        $futureWeek = (new DateTime('now'))->modify('next monday')->format('Y-m-d');
+
+        $pastRows = [];
+        $currentRows = [];
+        $futureRows = [];
+
+        foreach ($rows as $row) {
+            if ($row['startDate'] >= $futureWeek) {
+                $futureRows[] = $row;
+            } elseif ($row['startDate'] >= $currentWeek) {
+                $currentRows[] = $row;
+            } else {
+                $pastRows[] = $row;
+            }
+        }
+
+        return [$pastRows, $currentRows, $futureRows];
+    }
+
+    public function countSubmittedWeeks(array $rows): int
+    {
+        return count(array_filter(
+            $rows,
+            fn($row) =>
+            isset($row['status']) && $row['status'] === "submitted"
+        ));
+    }
+
+    private function filterByUsers(array $rows, array $selectedUsers): array
+    {
+        if (empty($selectedUsers)) {
+            return $rows;
+        }
+
+        $selectedUserIds = array_map(fn(User $user) => $user->getId(), $selectedUsers);
+        return array_filter($rows, fn($row) => in_array($row['userId'], $selectedUserIds));
+    }
+
+    private function filterByDateRange(array $rows, ?DateRange $dateRange): array
+    {
+        if ($dateRange === null || $dateRange->getBegin() === null || $dateRange->getEnd() === null) {
+            return $rows;
+        }
+
+        $begin = $dateRange->getBegin();
+        $end = $dateRange->getEnd();
+
+        return array_filter($rows, function ($row) use ($begin, $end) {
+            $weekStart = $row['week']->value;
+            $weekEnd = (clone $weekStart)->modify('+6 days');
+            return ($weekStart >= $begin && $weekStart <= $end) ||
+                ($weekEnd >= $begin && $weekEnd <= $end);
+        });
+    }
+
+    private function filterByStatus(array $rows, array $selectedStatus): array
+    {
+        if (empty($selectedStatus)) {
+            return $rows;
+        }
+
+        return array_filter($rows, fn($row) => in_array($row['status'], $selectedStatus));
+    }
+
+    private function filterBySearchTerm(array $rows, $searchTerm): array
+    {
+        if ($searchTerm === null || empty($searchTerm->getSearchTerm())) {
+            return $rows;
+        }
+
+        $searchParts = $searchTerm->getParts();
+
+        return array_filter($rows, function ($row) use ($searchParts) {
+            foreach ($searchParts as $part) {
+                if (!$this->rowMatchesSearchTerm($row, mb_strtolower($part->getTerm()))) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+
+    private function rowMatchesSearchTerm(array $row, string $term): bool
+    {
+        $searchableFields = [
+            mb_strtolower($row['user']),
+            mb_strtolower($row['week']->label ?? ''),
+            mb_strtolower($row['status'])
+        ];
+
+        foreach ($searchableFields as $field) {
+            if (str_contains($field, $term)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function getTimesheetsForRow(array $row): array
+    {
+        $timesheetQuery = new TimesheetQuery();
+        $timesheetQuery->setUser($this->userRepository->find($row['userId']));
+
+        $dateRange = new DateRange();
+        $dateRange->setBegin($row['week']->value);
+        $dateRange->setEnd((clone $row['week']->value)->modify('+6 days')->setTime(23, 59, 59));
+        $timesheetQuery->setDateRange($dateRange);
+        $timesheetQuery->setOrderBy('date');
+        $timesheetQuery->setOrderBy('begin');
+        $timesheetQuery->setOrder(BaseQuery::ORDER_ASC);
+
+        return $this->timesheetRepository->getTimesheetsForQuery($timesheetQuery);
+    }
+
+    private function getBreakTimeErrors(array $timesheets): array
+    {
+        if (
+            !$this->settingsTool->isInConfiguration(ConfigEnum::APPROVAL_BREAKCHECKS_NY) &&
+            !$this->settingsTool->getConfiguration(ConfigEnum::APPROVAL_BREAKCHECKS_NY)
+        ) {
+            return [];
+        }
+
+        return $this->breakTimeCheckToolGER->checkBreakTime($timesheets);
+    }
+}
\ No newline at end of file
diff --git a/Service/AutoApprovalService.php b/Service/AutoApprovalService.php
new file mode 100644
index 0000000..bf7ceb8
--- /dev/null
+++ b/Service/AutoApprovalService.php
@@ -0,0 +1,152 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Service;
+
+use App\Form\Model\DateRange;
+use App\Repository\Query\BaseQuery;
+use App\Repository\Query\TimesheetQuery;
+use App\Repository\TimesheetRepository;
+use DateTime;
+use KimaiPlugin\ApprovalBundle\Entity\Approval;
+use KimaiPlugin\ApprovalBundle\Entity\ApprovalStatus;
+use KimaiPlugin\ApprovalBundle\Enumeration\ConfigEnum;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalRepository;
+use KimaiPlugin\ApprovalBundle\Toolbox\BreakTimeCheckToolGER;
+use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
+
+class AutoApprovalService
+{
+    public function __construct(
+        private ApprovalRepository $approvalRepository,
+        private TimesheetRepository $timesheetRepository,
+        private BreakTimeCheckToolGER $breakTimeCheckToolGER,
+        private SettingsTool $settingsTool
+    ) {
+    }
+
+    /**
+     * Process multiple approvals for auto-approval
+     * 
+     * @param Approval[] $approvals
+     * @return array{successful: int, failed: int, processedApprovals: Approval[]}
+     */
+    public function processApprovals(array $approvals): array
+    {
+        $countSuccessful = 0;
+        $countFailed = 0;
+        $processedApprovals = [];
+
+        foreach ($approvals as $approval) {
+            $result = $this->processSingleApproval($approval);
+
+            if ($result['approved']) {
+                $countSuccessful++;
+                $processedApprovals[] = $result['approval'];
+            } else {
+                $countFailed++;
+            }
+        }
+
+        return [
+            'successful' => $countSuccessful,
+            'failed' => $countFailed,
+            'processedApprovals' => $processedApprovals
+        ];
+    }
+
+    /**
+     * Process a single approval for auto-approval
+     * 
+     * @return array{approved: bool, approval: ?Approval, reason: string}
+     */
+    public function processSingleApproval(Approval $approval): array
+    {
+        // Check if approval has correct status
+        $approval = $this->approvalRepository->checkLastStatus(
+            $approval->getStartDate(),
+            $approval->getEndDate(),
+            $approval->getUser(),
+            ApprovalStatus::SUBMITTED,
+            $approval
+        );
+
+        if (!$approval) {
+            return [
+                'approved' => false,
+                'approval' => null,
+                'reason' => 'Invalid approval status'
+            ];
+        }
+
+        // Verify the last status is SUBMITTED
+        if ($approval->getHistory()[0]->getStatus()->getName() !== ApprovalStatus::SUBMITTED) {
+            return [
+                'approved' => false,
+                'approval' => $approval,
+                'reason' => 'Not in submitted status'
+            ];
+        }
+
+        // Get timesheets for validation
+        $timesheets = $this->getTimesheetsForApproval($approval);
+
+        // Check for errors
+        $errors = $this->validateTimesheets($timesheets);
+        $hasErrors = !empty(array_filter($errors));
+
+        if ($hasErrors) {
+            return [
+                'approved' => false,
+                'approval' => $approval,
+                'reason' => 'Timesheet validation errors found'
+            ];
+        }
+
+        // Approval can be auto-approved
+        return [
+            'approved' => true,
+            'approval' => $approval,
+            'reason' => 'Auto-approved successfully'
+        ];
+    }
+
+    /**
+     * Get timesheets for an approval period
+     */
+    public function getTimesheetsForApproval(Approval $approval): array
+    {
+        $timesheetQuery = new TimesheetQuery();
+        $timesheetQuery->setUser($approval->getUser());
+
+        $dateRange = new DateRange();
+        $dateRange->setBegin($approval->getStartDate());
+        $dateRange->setEnd((clone $approval->getEndDate())->setTime(23, 59, 59));
+        $timesheetQuery->setDateRange($dateRange);
+        $timesheetQuery->setOrderBy('date');
+        $timesheetQuery->setOrder(BaseQuery::ORDER_ASC);
+
+        return $this->timesheetRepository->getTimesheetsForQuery($timesheetQuery);
+    }
+
+    /**
+     * Validate timesheets for break time errors
+     */
+    public function validateTimesheets(array $timesheets): array
+    {
+        if (!$this->shouldCheckBreakTime()) {
+            return [];
+        }
+
+        return $this->breakTimeCheckToolGER->checkBreakTime($timesheets);
+    }
+
+    /**
+     * Check if break time validation is enabled
+     */
+    private function shouldCheckBreakTime(): bool
+    {
+        return $this->settingsTool->isInConfiguration(ConfigEnum::APPROVAL_BREAKCHECKS_NY) &&
+            $this->settingsTool->getConfiguration(ConfigEnum::APPROVAL_BREAKCHECKS_NY);
+
+    }
+}
diff --git a/Tests/Controller/WeekReportControllerTest.php b/Tests/Controller/WeekReportControllerTest.php
new file mode 100644
index 0000000..3b86e71
--- /dev/null
+++ b/Tests/Controller/WeekReportControllerTest.php
@@ -0,0 +1,222 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Tests\Controller;
+
+use App\Entity\User;
+use KimaiPlugin\ApprovalBundle\Controller\WeekReportController;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalHistoryRepository;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalRepository;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalTimesheetRepository;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalWorkdayHistoryRepository;
+use KimaiPlugin\ApprovalBundle\Repository\ReportRepository;
+use KimaiPlugin\ApprovalBundle\Service\ApprovalDataService;
+use KimaiPlugin\ApprovalBundle\Toolbox\BreakTimeCheckToolGER;
+use KimaiPlugin\ApprovalBundle\Toolbox\Formatting;
+use KimaiPlugin\ApprovalBundle\Toolbox\SecurityTool;
+use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
+use App\Repository\TimesheetRepository;
+use App\Repository\UserRepository;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Contracts\Translation\TranslatorInterface;
+
+/**
+ * Unit tests for WeekReportController structure and method signatures
+ * 
+ * Note: These are structural tests only. Full behavior testing would require
+ * functional tests (WebTestCase) due to Symfony framework dependencies.
+ */
+class WeekReportControllerTest extends TestCase
+{
+    private WeekReportController $controller;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        // Create minimal mocks just for controller instantiation
+        $this->controller = new WeekReportController(
+            $this->createMock(SettingsTool::class),
+            $this->createMock(SecurityTool::class),
+            $this->createMock(UserRepository::class),
+            $this->createMock(ApprovalHistoryRepository::class),
+            $this->createMock(ApprovalRepository::class),
+            $this->createMock(ApprovalWorkdayHistoryRepository::class),
+            new Formatting($this->createMock(TranslatorInterface::class)),
+            $this->createMock(TimesheetRepository::class),
+            $this->createMock(ApprovalTimesheetRepository::class),
+            $this->createMock(BreakTimeCheckToolGER::class),
+            $this->createMock(ReportRepository::class),
+            $this->createMock(ApprovalDataService::class)
+        );
+    }
+
+    /**
+     * Test that toApprove method exists and has correct signature
+     */
+    public function testToApproveMethodExists(): void
+    {
+        $reflection = new \ReflectionMethod($this->controller, 'toApprove');
+
+        $this->assertEquals('toApprove', $reflection->getName());
+        $this->assertTrue($reflection->isPublic());
+
+        // Check it returns Response
+        $returnType = $reflection->getReturnType();
+        $this->assertNotNull($returnType);
+        $this->assertEquals('Symfony\Component\HttpFoundation\Response', $returnType->getName());
+
+        // Check parameter count and types
+        $this->assertCount(2, $reflection->getParameters());
+    }
+
+    /**
+     * Test that toApprove has proper dependencies injected
+     */
+    public function testToApproveHasRequiredDependencies(): void
+    {
+        $reflection = new \ReflectionClass($this->controller);
+
+        // Verify ApprovalDataService dependency exists
+        $constructor = $reflection->getConstructor();
+        $this->assertNotNull($constructor);
+
+        $parameters = $constructor->getParameters();
+        $parameterNames = array_map(fn($p) => $p->getName(), $parameters);
+
+        $this->assertContains('approvalDataService', $parameterNames);
+    }
+
+    /**
+     * Test that helper methods exist for toApprove workflow
+     */
+    public function testToApproveHelperMethodsExist(): void
+    {
+        $reflection = new \ReflectionClass($this->controller);
+
+        // Check critical helper methods exist
+        $this->assertTrue($reflection->hasMethod('getUsersForApproval'));
+        $this->assertTrue($reflection->hasMethod('buildDataTable'));
+        $this->assertTrue($reflection->hasMethod('sortArrayByQuery'));
+    }
+
+    /**
+     * Test getUsersForApproval is private (implementation detail)
+     */
+    public function testGetUsersForApprovalIsPrivate(): void
+    {
+        $reflection = new \ReflectionMethod($this->controller, 'getUsersForApproval');
+
+        $this->assertTrue($reflection->isPrivate());
+        $this->assertCount(0, $reflection->getParameters());
+    }
+
+    /**
+     * Test buildDataTable is private
+     */
+    public function testBuildDataTableIsPrivate(): void
+    {
+        $reflection = new \ReflectionMethod($this->controller, 'buildDataTable');
+
+        $this->assertTrue($reflection->isPrivate());
+        $this->assertCount(3, $reflection->getParameters());
+    }
+
+    /**
+     * Test that toApprove workflow is properly structured
+     * This validates the refactoring maintains proper separation of concerns
+     */
+    public function testToApproveWorkflowStructure(): void
+    {
+        $method = new \ReflectionMethod($this->controller, 'toApprove');
+        $source = file_get_contents($method->getFileName());
+
+        // Extract just the toApprove method
+        $start = $method->getStartLine() - 1;
+        $end = $method->getEndLine();
+        $length = $end - $start;
+        $sourceLines = array_slice(file($method->getFileName()), $start, $length);
+        $methodSource = implode('', $sourceLines);
+
+        // Verify it uses ApprovalDataService methods (refactored code)
+        $this->assertStringContainsString('approvalDataService->fetchAndFilterApprovalRows', $methodSource);
+        $this->assertStringContainsString('approvalDataService->enrichRowsWithErrors', $methodSource);
+        $this->assertStringContainsString('approvalDataService->categorizeRowsByWeek', $methodSource);
+        $this->assertStringContainsString('approvalDataService->countSubmittedWeeks', $methodSource);
+
+        // Verify it still handles form and rendering
+        $this->assertStringContainsString('getToolbarForm', $methodSource);
+        $this->assertStringContainsString('render', $methodSource);
+    }
+
+    /**
+     * Test that toApprove method is not too complex after refactoring
+     */
+    public function testToApproveComplexityReduced(): void
+    {
+        $method = new \ReflectionMethod($this->controller, 'toApprove');
+
+        $start = $method->getStartLine() - 1;
+        $end = $method->getEndLine();
+        $length = $end - $start;
+
+        // After refactoring, method should be less than 60 lines
+        $this->assertLessThan(
+            60,
+            $length,
+            'toApprove method should be less than 60 lines after refactoring'
+        );
+    }
+
+    /**
+     * Test that refactored code maintains all template variables
+     */
+    public function testToApproveRendersWithCorrectTemplateVariables(): void
+    {
+        $method = new \ReflectionMethod($this->controller, 'toApprove');
+        $source = file_get_contents($method->getFileName());
+
+        $start = $method->getStartLine() - 1;
+        $end = $method->getEndLine();
+        $length = $end - $start;
+        $sourceLines = array_slice(file($method->getFileName()), $start, $length);
+        $methodSource = implode('', $sourceLines);
+
+        // Verify expected template variables are passed
+        $expectedVariables = [
+            'current_tab',
+            'all_rows_datatable',
+            'past_rows',
+            'current_rows',
+            'future_rows',
+            'weeks_submitted',
+            'auto_approve_success',
+            'auto_approve_fail',
+            'warningNoUsers'
+        ];
+
+        foreach ($expectedVariables as $variable) {
+            $this->assertStringContainsString(
+                "'$variable'",
+                $methodSource,
+                "Template should receive '$variable' variable"
+            );
+        }
+    }
+
+    /**
+     * Test that the controller uses dependency injection properly
+     */
+    public function testControllerUsesDependencyInjection(): void
+    {
+        $reflection = new \ReflectionClass($this->controller);
+        $constructor = $reflection->getConstructor();
+
+        $this->assertNotNull($constructor);
+        $this->assertTrue($constructor->isPublic());
+
+        // Verify all dependencies are constructor-injected (12 dependencies)
+        $this->assertCount(12, $constructor->getParameters());
+    }
+}
\ No newline at end of file
diff --git a/Tests/Integration/AutoApprovalFilteringTest.php b/Tests/Integration/AutoApprovalFilteringTest.php
new file mode 100644
index 0000000..2b6d029
--- /dev/null
+++ b/Tests/Integration/AutoApprovalFilteringTest.php
@@ -0,0 +1,275 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Tests\Integration;
+
+use App\Entity\User;
+use DateTime;
+use KimaiPlugin\ApprovalBundle\Entity\Approval;
+use KimaiPlugin\ApprovalBundle\Entity\ApprovalStatus;
+use KimaiPlugin\ApprovalBundle\Repository\Query\ApprovalQuery;
+use KimaiPlugin\ApprovalBundle\Service\AutoApprovalService;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalRepository;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalStatusRepository;
+use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\MockObject\MockObject;
+
+/**
+ * Integration test to verify that autoApprove only processes approvals
+ * that match the query filters set in toApprove
+ */
+class AutoApprovalFilteringTest extends TestCase
+{
+    private AutoApprovalService|MockObject $autoApprovalService;
+    private ApprovalRepository|MockObject $approvalRepository;
+    private SettingsTool|MockObject $settingsTool;
+
+    protected function setUp(): void
+    {
+        $this->approvalRepository = $this->createMock(ApprovalRepository::class);
+        $this->settingsTool = $this->createMock(SettingsTool::class);
+
+        // We'll verify the service receives the correct filtered approvals
+        $this->autoApprovalService = $this->createMock(AutoApprovalService::class);
+    }
+
+    /**
+     * Test that only approvals matching the query users filter get processed
+     */
+    public function testAutoApproveOnlyProcessesSelectedUsers(): void
+    {
+        // Setup: Create multiple users
+        $user1 = $this->createMockUser(1, 'Alice');
+        $user2 = $this->createMockUser(2, 'Bob');
+        $user3 = $this->createMockUser(3, 'Charlie');
+
+        // Create approvals for all users
+        $approval1 = $this->createMockApproval(1, $user1);
+        $approval2 = $this->createMockApproval(2, $user2);
+        $approval3 = $this->createMockApproval(3, $user3);
+
+        // Create query that ONLY selects user1 and user2
+        $query = new ApprovalQuery();
+        $query->setUsers([$user1, $user2]);
+
+        // Mock repository to return ONLY filtered approvals (matching the query)
+        $filteredApprovals = [$approval1, $approval2]; // user3's approval is NOT included
+
+        $this->approvalRepository->expects($this->once())
+            ->method('getUserApprovalsFiltered')
+            ->with(
+                $this->callback(function ($users) use ($user1, $user2) {
+                    // Verify the users parameter contains only the selected users
+                    return in_array($user1, $users) && in_array($user2, $users);
+                }),
+                $query
+            )
+            ->willReturn($filteredApprovals);
+
+        // Verify that ONLY the filtered approvals are processed
+        $this->autoApprovalService->expects($this->once())
+            ->method('processApprovals')
+            ->with($filteredApprovals)
+            ->willReturn([
+                'processedApprovals' => [$approval1, $approval2],
+                'successful' => 2,
+                'failed' => 0
+            ]);
+
+        // Execute: Call the repository method that autoApprove would call
+        $resultApprovals = $this->approvalRepository->getUserApprovalsFiltered([$user1, $user2], $query);
+
+        // Verify resultApprovals contains only filtered approvals
+        $this->assertCount(2, $resultApprovals);
+        $this->assertContains($approval1, $resultApprovals);
+        $this->assertContains($approval2, $resultApprovals);
+        $this->assertNotContains($approval3, $resultApprovals); // Charlie's approval excluded
+
+        // Process them
+        $processResult = $this->autoApprovalService->processApprovals($resultApprovals);
+
+        $this->assertEquals(2, $processResult['successful']);
+        $this->assertEquals(0, $processResult['failed']);
+    }
+
+    /**
+     * Test that date range filter is applied correctly
+     */
+    public function testAutoApproveRespectsDateRangeFilter(): void
+    {
+        $user = $this->createMockUser(1, 'Alice');
+
+        // Create approvals for different weeks
+        $approval1 = $this->createMockApproval(1, $user, '2026-01-20', '2026-01-26'); // Week 1
+        $approval2 = $this->createMockApproval(2, $user, '2026-01-27', '2026-02-02'); // Week 2
+        $approval3 = $this->createMockApproval(3, $user, '2026-02-03', '2026-02-09'); // Week 3
+
+        // Create query with date range for only Week 1 and 2
+        $query = new ApprovalQuery();
+        $query->setBegin(new DateTime('2026-01-20'));
+        $query->setEnd(new DateTime('2026-02-02'));
+
+        // Mock repository returns only approvals in date range
+        $filteredApprovals = [$approval1, $approval2]; // approval3 excluded
+
+        $this->approvalRepository->expects($this->once())
+            ->method('getUserApprovalsFiltered')
+            ->with($this->anything(), $query)
+            ->willReturn($filteredApprovals);
+
+        $this->autoApprovalService->expects($this->once())
+            ->method('processApprovals')
+            ->with($filteredApprovals)
+            ->willReturn([
+                'processedApprovals' => [$approval1, $approval2],
+                'successful' => 2,
+                'failed' => 0
+            ]);
+
+        $resultApprovals = $this->approvalRepository->getUserApprovalsFiltered([$user], $query);
+        $result = $this->autoApprovalService->processApprovals($resultApprovals);
+
+        $this->assertCount(2, $resultApprovals);
+        $this->assertNotContains($approval3, $resultApprovals); // Week 3 excluded
+    }
+
+    /**
+     * Test that status filter is applied correctly
+     */
+    public function testAutoApproveOnlyProcessesSubmittedStatus(): void
+    {
+        $user = $this->createMockUser(1, 'Alice');
+
+        $approval1 = $this->createMockApproval(1, $user);
+        $approval2 = $this->createMockApproval(2, $user);
+        $approval3 = $this->createMockApproval(3, $user);
+
+        // Create query filtering for "submitted" status only
+        $query = new ApprovalQuery();
+        $query->setStatus([ApprovalStatus::SUBMITTED]);
+
+        // Repository returns only submitted approvals
+        $filteredApprovals = [$approval1, $approval2]; // approval3 has different status
+
+        $this->approvalRepository->expects($this->once())
+            ->method('getUserApprovalsFiltered')
+            ->with($this->anything(), $query)
+            ->willReturn($filteredApprovals);
+
+        $this->autoApprovalService->expects($this->once())
+            ->method('processApprovals')
+            ->with($filteredApprovals)
+            ->willReturn([
+                'processedApprovals' => [$approval1, $approval2],
+                'successful' => 2,
+                'failed' => 0
+            ]);
+
+        $resultApprovals = $this->approvalRepository->getUserApprovalsFiltered([$user], $query);
+        $result = $this->autoApprovalService->processApprovals($resultApprovals);
+
+
+        $this->assertCount(2, $resultApprovals);
+        $this->assertEquals(2, $result['successful']);
+    }
+
+    /**
+     * Test that empty query users falls back to all team users
+     */
+    public function testAutoApproveUsesAllUsersWhenQueryIsEmpty(): void
+    {
+        $user1 = $this->createMockUser(1, 'Alice');
+        $user2 = $this->createMockUser(2, 'Bob');
+
+        // Query with NO user filter
+        $query = new ApprovalQuery();
+
+        // All team users should be used
+        $allUsers = [$user1, $user2];
+
+        $approval1 = $this->createMockApproval(1, $user1);
+        $approval2 = $this->createMockApproval(2, $user2);
+
+        $this->approvalRepository->expects($this->once())
+            ->method('getUserApprovalsFiltered')
+            ->with($allUsers, $query)
+            ->willReturn([$approval1, $approval2]);
+
+        $resultApprovals = $this->approvalRepository->getUserApprovalsFiltered($allUsers, $query);
+
+        $this->assertCount(2, $resultApprovals);
+    }
+
+    /**
+     * Test the complete workflow: query set in toApprove is used in autoApprove
+     */
+    public function testCompleteWorkflowQueryPassedBetweenActions(): void
+    {
+        // Simulate what happens in toApprove
+        $user1 = $this->createMockUser(1, 'Alice');
+        $user2 = $this->createMockUser(2, 'Bob');
+
+        // 1. User selects specific users in toApprove
+        $queryFromToApprove = new ApprovalQuery();
+        $queryFromToApprove->setUsers([$user1]); // Only Alice selected
+
+        // Simulate session storage (in real code: $request->getSession()->set('query', $query))
+        $sessionQuery = $queryFromToApprove;
+
+        // 2. In autoApprove, query is retrieved from session
+        $queryInAutoApprove = $sessionQuery;
+
+        // Verify it's the same query
+        $this->assertSame($queryFromToApprove, $queryInAutoApprove);
+        $this->assertEquals([$user1], $queryInAutoApprove->getUsers());
+
+        // 3. Only Alice's approvals should be fetched
+        $approval1 = $this->createMockApproval(1, $user1);
+
+        $this->approvalRepository->expects($this->once())
+            ->method('getUserApprovalsFiltered')
+            ->with(
+                $this->callback(function ($users) use ($user1) {
+                    return count($users) === 1 && $users[0] === $user1;
+                }),
+                $queryInAutoApprove
+            )
+            ->willReturn([$approval1]);
+
+        // Execute
+        $resultApprovals = $this->approvalRepository->getUserApprovalsFiltered(
+            $queryInAutoApprove->getUsers(),
+            $queryInAutoApprove
+        );
+
+        // Verify only Alice's approval is processed
+        $this->assertCount(1, $resultApprovals);
+        $this->assertEquals($approval1, $resultApprovals[0]);
+    }
+
+    // Helper methods
+
+    private function createMockUser(int $id, string $name): User|MockObject
+    {
+        $user = $this->createMock(User::class);
+        $user->method('getId')->willReturn($id);
+        $user->method('getUsername')->willReturn($name);
+        $user->method('getDisplayName')->willReturn($name);
+        return $user;
+    }
+
+    private function createMockApproval(
+        int $id,
+        User $user,
+        string $startDate = '2026-01-20',
+        string $endDate = '2026-01-26'
+    ): Approval|MockObject {
+        $approval = $this->createMock(Approval::class);
+        $approval->method('getId')->willReturn($id);
+        $approval->method('getUser')->willReturn($user);
+        $approval->method('getStartDate')->willReturn(new DateTime($startDate));
+        $approval->method('getEndDate')->willReturn(new DateTime($endDate));
+        $approval->method('getHistory')->willReturn([]);
+        return $approval;
+    }
+}
\ No newline at end of file
diff --git a/Tests/Repository/ApprovalRepositoryTest.php b/Tests/Repository/ApprovalRepositoryTest.php
new file mode 100644
index 0000000..13755e6
--- /dev/null
+++ b/Tests/Repository/ApprovalRepositoryTest.php
@@ -0,0 +1,696 @@
+<?php
+
+/*
+ * This file is part of the Kimai time-tracking app.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace KimaiPlugin\ApprovalBundle\Tests\Repository;
+
+use App\Entity\User;
+use App\Repository\TimesheetRepository;
+use App\Utils\SearchTerm;
+use DateTime;
+use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\Query;
+use Doctrine\ORM\QueryBuilder;
+use KimaiPlugin\ApprovalBundle\Entity\Approval;
+use KimaiPlugin\ApprovalBundle\Entity\ApprovalHistory;
+use KimaiPlugin\ApprovalBundle\Entity\ApprovalStatus;
+use KimaiPlugin\ApprovalBundle\Enumeration\ConfigEnum;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalHistoryRepository;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalOvertimeHistoryRepository;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalRepository;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalWorkdayHistoryRepository;
+use KimaiPlugin\ApprovalBundle\Repository\LockdownRepository;
+use KimaiPlugin\ApprovalBundle\Repository\Query\ApprovalQuery;
+use KimaiPlugin\ApprovalBundle\Repository\ReportRepository;
+use KimaiPlugin\ApprovalBundle\Settings\ApprovalSettingsInterface;
+use KimaiPlugin\ApprovalBundle\Toolbox\Formatting;
+use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
+use Doctrine\ORM\Query\Expr;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
+
+/**
+ * Unit tests for ApprovalRepository::getUserApprovalsFiltered()
+ */
+class ApprovalRepositoryTest extends TestCase
+{
+    /**
+     * @var ApprovalRepository
+     */
+    private ApprovalRepository $repository;
+
+    /**
+     * @var MockObject|EntityManager
+     */
+    private $entityManager;
+
+    /**
+     * @var MockObject|QueryBuilder
+     */
+    private $queryBuilder;
+
+    /**
+     * @var MockObject|Query
+     */
+    private $query;
+
+    /**
+     * @var MockObject|SettingsTool
+     */
+    private $settingsTool;
+
+    /**
+     * @var MockObject|ApprovalSettingsInterface
+     */
+    private $metaFieldSettings;
+
+    /**
+     * @var Formatting
+     */
+    private Formatting $formatting;
+
+    /**
+     * @var MockObject|UrlGeneratorInterface
+     */
+    private $urlGenerator;
+
+    protected function setUp(): void
+    {
+        $this->entityManager = $this->createMock(EntityManager::class);
+        $this->queryBuilder = $this->createMock(QueryBuilder::class);
+        $this->query = $this->createMock(Query::class);
+        $this->settingsTool = $this->createMock(SettingsTool::class);
+        $this->metaFieldSettings = $this->createMock(ApprovalSettingsInterface::class);
+        $this->formatting = new Formatting($this->createMock(\Symfony\Contracts\Translation\TranslatorInterface::class));
+        $this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
+
+        // Mock repositories
+        $approvalWorkdayRepo = $this->createMock(ApprovalWorkdayHistoryRepository::class);
+        $approvalOvertimeRepo = $this->createMock(ApprovalOvertimeHistoryRepository::class);
+        $reportRepository = $this->createMock(ReportRepository::class);
+        $timesheetRepository = $this->createMock(TimesheetRepository::class);
+
+        $this->repository = new ApprovalRepository(
+            $this->createMock(\Doctrine\Persistence\ManagerRegistry::class),
+            $this->metaFieldSettings,
+            $approvalWorkdayRepo,
+            $approvalOvertimeRepo,
+            $reportRepository,
+            $timesheetRepository,
+            $this->settingsTool,
+            $this->formatting,
+            $this->urlGenerator
+        );
+
+        // Override the entity manager with our mock
+        $reflection = new \ReflectionClass($this->repository);
+        $property = $reflection->getProperty('_em');
+        $property->setAccessible(true);
+        $property->setValue($this->repository, $this->entityManager);
+
+        // Setup ExpressionBuilder mock
+        $this->setupExpressionBuilder();
+    }
+
+    /**
+     * Setup ExpressionBuilder mock to handle in() method
+     */
+    private function setupExpressionBuilder(): void
+    {
+        $expressionBuilder = $this->createMock(Expr::class);
+        $expressionBuilder->method('in')
+            ->willReturn('u.id IN (:usersId)');
+
+        $this->entityManager->method('getExpressionBuilder')
+            ->willReturn($expressionBuilder);
+    }
+
+    /**
+     * Test with empty users array returns empty result
+     */
+    public function testGetUserApprovalsFilteredWithEmptyUsersArray(): void
+    {
+        $query = new ApprovalQuery();
+        $result = $this->repository->getUserApprovalsFiltered([], $query);
+
+        $this->assertIsArray($result);
+        $this->assertEmpty($result);
+    }
+
+    /**
+     * Test with users but no filters applied
+     */
+    public function testGetUserApprovalsFilteredWithUsersNoFilters(): void
+    {
+        // Setup default configuration mock
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn('2025-01-01');
+
+        // Create test data with multiple approvals - different statuses
+        $user = $this->createTestUser(1, 'john.doe');
+        $approvalSubmitted = $this->createTestApproval(
+            $user,
+            new DateTime('2025-01-06'),
+            new DateTime('2025-01-12'),
+            ApprovalStatus::SUBMITTED
+        );
+        $approvalApproved = $this->createTestApproval(
+            $user,
+            new DateTime('2025-01-13'),
+            new DateTime('2025-01-19'),
+            ApprovalStatus::APPROVED
+        );
+
+        // Setup QueryBuilder mock chain
+        $this->queryBuilder->method('select')->willReturnSelf();
+        $this->queryBuilder->method('from')->willReturnSelf();
+        $this->queryBuilder->method('join')->willReturnSelf();
+        $this->queryBuilder->method('andWhere')->willReturnSelf();
+        $this->queryBuilder->method('setParameter')->willReturnSelf();
+        $this->queryBuilder->method('getQuery')->willReturn($this->query);
+
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        $this->query->method('getResult')->willReturn([$approvalSubmitted, $approvalApproved]);
+
+        // Execute
+        $result = $this->repository->getUserApprovalsFiltered([$user], new ApprovalQuery());
+
+        // Assert - should only return SUBMITTED approval, not APPROVED
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test with date range filter (dateRangeStart)
+     */
+    public function testGetUserApprovalsFilteredWithDateRangeStart(): void
+    {
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn('2025-01-01');
+
+        $user = $this->createTestUser(1, 'john.doe');
+        // Approval before date range
+        $approvalBefore = $this->createTestApproval(
+            $user,
+            new DateTime('2025-01-06'),
+            new DateTime('2025-01-12'),
+            ApprovalStatus::SUBMITTED
+        );
+        // Approval within date range
+        $approvalWithin = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-10'),
+            new DateTime('2025-02-16'),
+            ApprovalStatus::SUBMITTED
+        );
+        // Approval with different status
+        $approvalDenied = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-17'),
+            new DateTime('2025-02-23'),
+            ApprovalStatus::DENIED
+        );
+
+        // Setup QueryBuilder expectations
+        $this->setupQueryBuilderChain();
+
+        // Create query with date range start in the middle
+        $approvalQuery = new ApprovalQuery();
+        $approvalQuery->setBegin(new DateTime('2025-02-01'));
+
+        // Verify andWhere is called for date range
+        $this->queryBuilder->expects($this->atLeastOnce())
+            ->method('andWhere')
+            ->willReturnSelf();
+
+        $this->queryBuilder->expects($this->atLeastOnce())
+            ->method('setParameter')
+            ->willReturnSelf();
+
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        // Only return approvals that are after Feb 1st
+        $this->query->method('getResult')->willReturn([$approvalWithin, $approvalDenied]);
+
+        $result = $this->repository->getUserApprovalsFiltered([$user], $approvalQuery);
+
+        // Should only contain SUBMITTED approval within range
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test with date range filter (dateRangeEnd)
+     */
+    public function testGetUserApprovalsFilteredWithDateRangeEnd(): void
+    {
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn('2025-01-01');
+
+        $user = $this->createTestUser(1, 'john.doe');
+        // Approval within date range
+        $approvalWithin = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-06'),
+            new DateTime('2025-02-12'),
+            ApprovalStatus::SUBMITTED
+        );
+        // Approval after date range
+        $approvalAfter = $this->createTestApproval(
+            $user,
+            new DateTime('2025-03-06'),
+            new DateTime('2025-03-12'),
+            ApprovalStatus::APPROVED
+        );
+        // Another approval outside range with different status
+        $approvalOutside = $this->createTestApproval(
+            $user,
+            new DateTime('2025-03-13'),
+            new DateTime('2025-03-19'),
+            ApprovalStatus::DENIED
+        );
+
+        $this->setupQueryBuilderChain();
+
+        // Create query with date range end in the middle
+        $approvalQuery = new ApprovalQuery();
+        $approvalQuery->setEnd(new DateTime('2025-02-28'));
+
+        $this->queryBuilder->expects($this->atLeastOnce())
+            ->method('andWhere')
+            ->willReturnSelf();
+
+        $this->queryBuilder->expects($this->atLeastOnce())
+            ->method('setParameter')
+            ->willReturnSelf();
+
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        // Only return approvals that are before Feb 28
+        $this->query->method('getResult')->willReturn([$approvalWithin, $approvalAfter]);
+
+        $result = $this->repository->getUserApprovalsFiltered([$user], $approvalQuery);
+
+        // Should only contain SUBMITTED approval within range
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test with both date range filters (start and end)
+     */
+    public function testGetUserApprovalsFilteredWithDateRangeStartAndEnd(): void
+    {
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn('2025-01-01');
+
+        $user = $this->createTestUser(1, 'john.doe');
+        // Approval before date range
+        $approvalBefore = $this->createTestApproval(
+            $user,
+            new DateTime('2025-01-06'),
+            new DateTime('2025-01-12'),
+            ApprovalStatus::SUBMITTED
+        );
+        // Approval within date range
+        $approvalWithin = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-10'),
+            new DateTime('2025-02-16'),
+            ApprovalStatus::SUBMITTED
+        );
+        // Approval after date range
+        $approvalAfter = $this->createTestApproval(
+            $user,
+            new DateTime('2025-03-10'),
+            new DateTime('2025-03-16'),
+            ApprovalStatus::DENIED
+        );
+
+        $this->setupQueryBuilderChain();
+
+        // Create query with both date range filters in the middle
+        $approvalQuery = new ApprovalQuery();
+        $approvalQuery->setBegin(new DateTime('2025-02-01'));
+        $approvalQuery->setEnd(new DateTime('2025-02-28'));
+
+        $this->queryBuilder->expects($this->atLeastOnce())
+            ->method('andWhere')
+            ->willReturnSelf();
+
+        $this->queryBuilder->expects($this->atLeastOnce())
+            ->method('setParameter')
+            ->willReturnSelf();
+
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        // Only return approvals within Feb range
+        $this->query->method('getResult')->willReturn([$approvalWithin, $approvalAfter]);
+
+        $result = $this->repository->getUserApprovalsFiltered([$user], $approvalQuery);
+
+        // Should only contain SUBMITTED approval within range
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test with search term filter
+     */
+    public function testGetUserApprovalsFilteredWithSearchTerm(): void
+    {
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn('2025-01-01');
+
+        $user = $this->createTestUser(1, 'john.doe');
+        $user->setAlias('john');
+
+        $approvalSubmitted = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-06'),
+            new DateTime('2025-02-12'),
+            ApprovalStatus::SUBMITTED
+        );
+        $approvalApproved = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-13'),
+            new DateTime('2025-02-19'),
+            ApprovalStatus::APPROVED
+        );
+
+        $this->setupQueryBuilderChain();
+
+        // Create query with search term
+        $approvalQuery = new ApprovalQuery();
+        $approvalQuery->setSearchTerm(new SearchTerm('john'));
+
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        $this->query->method('getResult')->willReturn([$approvalSubmitted, $approvalApproved]);
+
+        $result = $this->repository->getUserApprovalsFiltered([$user], $approvalQuery);
+
+        // Should only contain SUBMITTED approval
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test that filters out non-submitted approvals
+     */
+    public function testGetUserApprovalsFilteredFiltersNonSubmittedApprovals(): void
+    {
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn('2025-01-01');
+
+        $user = $this->createTestUser(1, 'john.doe');
+
+        // Create approval with non-submitted status
+        $approval = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-06'),
+            new DateTime('2025-02-12'),
+            ApprovalStatus::APPROVED // Not submitted
+        );
+
+        $this->setupQueryBuilderChain();
+
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        $this->query->method('getResult')->willReturn([$approval]);
+
+        $result = $this->repository->getUserApprovalsFiltered([$user], new ApprovalQuery());
+
+        // Should be empty because approval status is APPROVED, not SUBMITTED
+        $this->assertIsArray($result);
+        $this->assertEmpty($result);
+    }
+
+    /**
+     * Test with multiple users
+     */
+    public function testGetUserApprovalsFilteredWithMultipleUsers(): void
+    {
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn('2025-01-01');
+
+        $user1 = $this->createTestUser(1, 'john.doe');
+        $user2 = $this->createTestUser(2, 'jane.doe');
+
+        $approval1Submitted = $this->createTestApproval(
+            $user1,
+            new DateTime('2025-02-06'),
+            new DateTime('2025-02-12'),
+            ApprovalStatus::SUBMITTED
+        );
+
+        $approval2Submitted = $this->createTestApproval(
+            $user2,
+            new DateTime('2025-02-06'),
+            new DateTime('2025-02-12'),
+            ApprovalStatus::SUBMITTED
+        );
+
+        $approval1Denied = $this->createTestApproval(
+            $user1,
+            new DateTime('2025-02-13'),
+            new DateTime('2025-02-19'),
+            ApprovalStatus::DENIED
+        );
+
+        $this->setupQueryBuilderChain();
+
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        $this->query->method('getResult')->willReturn([$approval1Submitted, $approval2Submitted, $approval1Denied]);
+
+        $result = $this->repository->getUserApprovalsFiltered([$user1, $user2], new ApprovalQuery());
+
+        // Should only contain SUBMITTED approvals
+        $this->assertIsArray($result);
+        $this->assertCount(2, $result);
+    }
+
+    /**
+     * Test with custom start date parameter
+     */
+    public function testGetUserApprovalsFilteredWithCustomStartDate(): void
+    {
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn('2025-01-01');
+
+        $user = $this->createTestUser(1, 'john.doe');
+        $approvalSubmitted = $this->createTestApproval(
+            $user,
+            new DateTime('2025-03-06'),
+            new DateTime('2025-03-12'),
+            ApprovalStatus::SUBMITTED
+        );
+        $approvalApproved = $this->createTestApproval(
+            $user,
+            new DateTime('2025-03-13'),
+            new DateTime('2025-03-19'),
+            ApprovalStatus::APPROVED
+        );
+
+        $this->setupQueryBuilderChain();
+
+        $customStartDate = new DateTime('2025-03-01');
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        $this->query->method('getResult')->willReturn([$approvalSubmitted, $approvalApproved]);
+
+        $result = $this->repository->getUserApprovalsFiltered([$user], new ApprovalQuery(), $customStartDate);
+
+        // Should only contain SUBMITTED approval
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test with empty configuration value for APPROVAL_WORKFLOW_START
+     */
+    public function testGetUserApprovalsFilteredWithEmptyWorkflowStartConfig(): void
+    {
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn(''); // Empty configuration
+
+        $user = $this->createTestUser(1, 'john.doe');
+        $approvalSubmitted = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-06'),
+            new DateTime('2025-02-12'),
+            ApprovalStatus::SUBMITTED
+        );
+        $approvalDenied = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-13'),
+            new DateTime('2025-02-19'),
+            ApprovalStatus::DENIED
+        );
+
+        $this->setupQueryBuilderChain();
+
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        $this->query->method('getResult')->willReturn([$approvalSubmitted, $approvalDenied]);
+
+        $result = $this->repository->getUserApprovalsFiltered([$user], new ApprovalQuery());
+
+        // Should only contain SUBMITTED approval
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test search term filtering with username match
+     */
+    public function testGetUserApprovalsFilteredSearchByUsername(): void
+    {
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn('2025-01-01');
+
+        $user = $this->createTestUser(1, 'john.doe');
+        $approvalSubmitted = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-06'),
+            new DateTime('2025-02-12'),
+            ApprovalStatus::SUBMITTED
+        );
+        $approvalApproved = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-13'),
+            new DateTime('2025-02-19'),
+            ApprovalStatus::APPROVED
+        );
+
+        $this->setupQueryBuilderChain();
+
+        $approvalQuery = new ApprovalQuery();
+        $approvalQuery->setSearchTerm(new SearchTerm('john'));
+
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        $this->query->method('getResult')->willReturn([$approvalSubmitted, $approvalApproved]);
+
+        $result = $this->repository->getUserApprovalsFiltered([$user], $approvalQuery);
+
+        // Should only contain SUBMITTED approval
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test combined filters: date range + search term
+     */
+    public function testGetUserApprovalsFilteredCombinedDateRangeAndSearch(): void
+    {
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_WORKFLOW_START)
+            ->willReturn('2025-01-01');
+
+        $user = $this->createTestUser(1, 'john.doe');
+        // Approval before date range
+        $approvalBefore = $this->createTestApproval(
+            $user,
+            new DateTime('2025-01-06'),
+            new DateTime('2025-01-12'),
+            ApprovalStatus::SUBMITTED
+        );
+        // Approval within date range
+        $approvalWithin = $this->createTestApproval(
+            $user,
+            new DateTime('2025-02-10'),
+            new DateTime('2025-02-16'),
+            ApprovalStatus::SUBMITTED
+        );
+        // Approval after date range with different status
+        $approvalAfter = $this->createTestApproval(
+            $user,
+            new DateTime('2025-03-10'),
+            new DateTime('2025-03-16'),
+            ApprovalStatus::DENIED
+        );
+
+        $this->setupQueryBuilderChain();
+
+        $approvalQuery = new ApprovalQuery();
+        $approvalQuery->setBegin(new DateTime('2025-02-01'));
+        $approvalQuery->setEnd(new DateTime('2025-02-28'));
+        $approvalQuery->setSearchTerm(new SearchTerm('john'));
+
+        $this->queryBuilder->expects($this->atLeastOnce())
+            ->method('andWhere')
+            ->willReturnSelf();
+
+        $this->entityManager->method('createQueryBuilder')->willReturn($this->queryBuilder);
+        // Only return approvals within Feb range
+        $this->query->method('getResult')->willReturn([$approvalWithin, $approvalAfter]);
+
+        $result = $this->repository->getUserApprovalsFiltered([$user], $approvalQuery);
+
+        // Should only contain SUBMITTED approval within range
+        $this->assertIsArray($result);
+        $this->assertCount(1, $result);
+    }
+
+    // Helper methods
+
+    /**
+     * Create a test user with given ID and username
+     */
+    private function createTestUser(int $id, string $username): User
+    {
+        $user = $this->createMock(User::class);
+        $user->method('getId')->willReturn($id);
+        $user->method('getUsername')->willReturn($username);
+        $user->method('getAlias')->willReturn(null);
+        $user->method('getDisplayName')->willReturn($username);
+
+        return $user;
+    }
+
+    /**
+     * Create a test approval with given parameters
+     */
+    private function createTestApproval(
+        User $user,
+        DateTime $startDate,
+        DateTime $endDate,
+        string $statusName
+    ): Approval {
+        $status = $this->createMock(ApprovalStatus::class);
+        $status->method('getName')->willReturn($statusName);
+
+        $history = $this->createMock(ApprovalHistory::class);
+        $history->method('getStatus')->willReturn($status);
+
+        $approval = $this->createMock(Approval::class);
+        $approval->method('getUser')->willReturn($user);
+        $approval->method('getStartDate')->willReturn($startDate);
+        $approval->method('getEndDate')->willReturn($endDate);
+        $approval->method('getHistory')->willReturn([$history]);
+
+        return $approval;
+    }
+
+    /**
+     * Setup QueryBuilder mock chain with default behaviors
+     */
+    private function setupQueryBuilderChain(): void
+    {
+        $this->queryBuilder->method('select')->willReturnSelf();
+        $this->queryBuilder->method('from')->willReturnSelf();
+        $this->queryBuilder->method('join')->willReturnSelf();
+        $this->queryBuilder->method('andWhere')->willReturnSelf();
+        $this->queryBuilder->method('setParameter')->willReturnSelf();
+        $this->queryBuilder->method('getQuery')->willReturn($this->query);
+    }
+}
diff --git a/Tests/Service/ApprovalDataServiceTest.php b/Tests/Service/ApprovalDataServiceTest.php
new file mode 100644
index 0000000..e6a6480
--- /dev/null
+++ b/Tests/Service/ApprovalDataServiceTest.php
@@ -0,0 +1,708 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Tests\Service;
+
+use App\Entity\User;
+use App\Form\Model\DateRange;
+use App\Repository\Query\BaseQuery;
+use App\Repository\Query\TimesheetQuery;
+use App\Repository\TimesheetRepository;
+use App\Repository\UserRepository;
+use DateTime;
+use KimaiPlugin\ApprovalBundle\Entity\ApprovalStatus;
+use KimaiPlugin\ApprovalBundle\Enumeration\ConfigEnum;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalRepository;
+use KimaiPlugin\ApprovalBundle\Repository\Query\ApprovalQuery;
+use KimaiPlugin\ApprovalBundle\Service\ApprovalDataService;
+use KimaiPlugin\ApprovalBundle\Toolbox\BreakTimeCheckToolGER;
+use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+
+class ApprovalDataServiceTest extends TestCase
+{
+    private ApprovalDataService $service;
+    private MockObject|ApprovalRepository $approvalRepository;
+    private MockObject|UserRepository $userRepository;
+    private MockObject|TimesheetRepository $timesheetRepository;
+    private MockObject|BreakTimeCheckToolGER $breakTimeCheckToolGER;
+    private MockObject|SettingsTool $settingsTool;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->approvalRepository = $this->createMock(ApprovalRepository::class);
+        $this->userRepository = $this->createMock(UserRepository::class);
+        $this->timesheetRepository = $this->createMock(TimesheetRepository::class);
+        $this->breakTimeCheckToolGER = $this->createMock(BreakTimeCheckToolGER::class);
+        $this->settingsTool = $this->createMock(SettingsTool::class);
+
+        $this->service = new ApprovalDataService(
+            $this->approvalRepository,
+            $this->userRepository,
+            $this->timesheetRepository,
+            $this->breakTimeCheckToolGER,
+            $this->settingsTool
+        );
+    }
+
+    /**
+     * Test fetchAndFilterApprovalRows with no filters
+     */
+    public function testFetchAndFilterApprovalRowsWithoutFilters(): void
+    {
+        $users = [$this->createMock(User::class)];
+        $query = new ApprovalQuery();
+
+        $mockRows = [
+            ['userId' => 1, 'user' => 'John Doe', 'status' => ApprovalStatus::SUBMITTED],
+            ['userId' => 2, 'user' => 'Jane Smith', 'status' => ApprovalStatus::APPROVED],
+        ];
+
+
+        $this->approvalRepository->expects($this->once())
+            ->method('findAllWeek')
+            ->with($users)
+            ->willReturn($mockRows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->with(ConfigEnum::APPROVAL_HIDE_APPROVED_NY, false)
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, $users);
+
+        $this->assertCount(2, $result);
+        $this->assertEquals($mockRows, array_values($result));
+    }
+
+    /**
+     * Test fetchAndFilterApprovalRows with hide approved enabled
+     */
+    public function testFetchAndFilterApprovalRowsHidesApproved(): void
+    {
+        $users = [$this->createMock(User::class)];
+        $query = new ApprovalQuery();
+
+        $allRows = [
+            ['userId' => 1, 'status' => ApprovalStatus::SUBMITTED],
+            ['userId' => 2, 'status' => ApprovalStatus::APPROVED],
+        ];
+
+        $filteredRows = [
+            ['userId' => 1, 'status' => ApprovalStatus::SUBMITTED],
+        ];
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($allRows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->with(ConfigEnum::APPROVAL_HIDE_APPROVED_NY, false)
+            ->willReturn(true);
+
+        $this->approvalRepository->expects($this->once())
+            ->method('filterWeeksNotApproved')
+            ->with($allRows)
+            ->willReturn($filteredRows);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, $users);
+
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test fetchAndFilterApprovalRows filters by users
+     */
+    public function testFetchAndFilterApprovalRowsFiltersByUsers(): void
+    {
+        $user1 = $this->createMock(User::class);
+        $user1->method('getId')->willReturn(1);
+
+        $user2 = $this->createMock(User::class);
+        $user2->method('getId')->willReturn(2);
+
+        $users = [$user1, $user2];
+        $query = new ApprovalQuery();
+        $query->setUsers([$user1]);
+
+        $allRows = [
+            ['userId' => 1, 'user' => 'User1', 'status' => ApprovalStatus::SUBMITTED],
+            ['userId' => 2, 'user' => 'User2', 'status' => ApprovalStatus::SUBMITTED],
+            ['userId' => 3, 'user' => 'User3', 'status' => ApprovalStatus::SUBMITTED],
+        ];
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($allRows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, $users);
+
+        $this->assertCount(1, $result);
+        $filteredResult = array_values($result);
+        $this->assertEquals(1, $filteredResult[0]['userId']);
+    }
+
+    /**
+     * Test fetchAndFilterApprovalRows filters by date range
+     */
+    public function testFetchAndFilterApprovalRowsFiltersByDateRange(): void
+    {
+        $users = [$this->createMock(User::class)];
+        $query = new ApprovalQuery();
+
+        $dateRange = new DateRange();
+        $dateRange->setBegin(new DateTime('2026-01-20'));
+        $dateRange->setEnd(new DateTime('2026-01-26'));
+        $query->setDateRange($dateRange);
+
+        $allRows = [
+            [
+                'userId' => 1,
+                'week' => (object) ['value' => new DateTime('2026-01-20')],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+            [
+                'userId' => 2,
+                'week' => (object) ['value' => new DateTime('2026-01-13')],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+            [
+                'userId' => 3,
+                'week' => (object) ['value' => new DateTime('2026-01-27')],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+        ];
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($allRows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, $users);
+
+        // Should include row with week starting 2026-01-20 (within range)
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(1, array_values($result)[0]['userId']);
+    }
+
+    /**
+     * Test fetchAndFilterApprovalRows filters by status
+     */
+    public function testFetchAndFilterApprovalRowsFiltersByStatus(): void
+    {
+        $users = [$this->createMock(User::class)];
+        $query = new ApprovalQuery();
+        $query->setStatus([ApprovalStatus::SUBMITTED, ApprovalStatus::NOT_SUBMITTED]);
+
+        $allRows = [
+            ['userId' => 1, 'status' => ApprovalStatus::SUBMITTED],
+            ['userId' => 2, 'status' => ApprovalStatus::APPROVED],
+            ['userId' => 3, 'status' => ApprovalStatus::NOT_SUBMITTED],
+            ['userId' => 4, 'status' => ApprovalStatus::DENIED],
+        ];
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($allRows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, $users);
+
+        $this->assertCount(2, $result);
+        $resultArray = array_values($result);
+        $this->assertContains($resultArray[0]['status'], [ApprovalStatus::SUBMITTED, ApprovalStatus::NOT_SUBMITTED]);
+        $this->assertContains($resultArray[1]['status'], [ApprovalStatus::SUBMITTED, ApprovalStatus::NOT_SUBMITTED]);
+    }
+
+    /**
+     * Test fetchAndFilterApprovalRows filters by search term
+     */
+    public function testFetchAndFilterApprovalRowsFiltersBySearchTerm(): void
+    {
+        $users = [$this->createMock(User::class)];
+        $query = new ApprovalQuery();
+
+        // Use real SearchTerm instead of mock
+        $searchTerm = new \App\Utils\SearchTerm('John');
+        $query->setSearchTerm($searchTerm);
+
+        $allRows = [
+            [
+                'userId' => 1,
+                'user' => 'John Doe',
+                'week' => (object) ['label' => 'Week 4'],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+            [
+                'userId' => 2,
+                'user' => 'Jane Smith',
+                'week' => (object) ['label' => 'Week 4'],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+        ];
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($allRows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, $users);
+
+        $this->assertCount(1, $result);
+        $filteredResult = array_values($result);
+        $this->assertStringContainsString('John', $filteredResult[0]['user']);
+    }
+
+    /**
+     * Test enrichRowsWithErrors with break time errors
+     */
+    public function testEnrichRowsWithErrorsAddsErrorFlag(): void
+    {
+        $user = $this->createMock(User::class);
+        $user->method('getId')->willReturn(1);
+
+        $rows = [
+            [
+                'userId' => 1,
+                'week' => (object) ['value' => new DateTime('2026-01-20')],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+            [
+                'userId' => 1,
+                'week' => (object) ['value' => new DateTime('2026-01-27')],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+        ];
+
+        $this->userRepository->method('find')
+            ->with(1)
+            ->willReturn($user);
+
+        $this->timesheetRepository->method('getTimesheetsForQuery')
+            ->willReturn([]);
+
+        // First row has errors, second doesn't
+        $this->breakTimeCheckToolGER->method('checkBreakTime')
+            ->willReturnOnConsecutiveCalls(
+                ['2026-01-20' => 'Break time violation'],
+                []
+            );
+
+        $this->settingsTool->method('isInConfiguration')
+            ->with(ConfigEnum::APPROVAL_BREAKCHECKS_NY)
+            ->willReturn(true);
+
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_BREAKCHECKS_NY)
+            ->willReturn(true);
+
+        $result = $this->service->enrichRowsWithErrors($rows);
+
+        $this->assertTrue($result[0]['hasErrors']);
+        $this->assertFalse($result[1]['hasErrors']);
+    }
+
+    /**
+     * Test enrichRowsWithErrors when break checks disabled
+     */
+    public function testEnrichRowsWithErrorsWhenBreakChecksDisabled(): void
+    {
+        $user = $this->createMock(User::class);
+        $user->method('getId')->willReturn(1);
+
+        $rows = [
+            [
+                'userId' => 1,
+                'week' => (object) ['value' => new DateTime('2026-01-20')],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+        ];
+
+        $this->userRepository->method('find')
+            ->with(1)
+            ->willReturn($user);
+
+        $this->timesheetRepository->method('getTimesheetsForQuery')
+            ->willReturn([]);
+
+        $this->settingsTool->method('isInConfiguration')
+            ->with(ConfigEnum::APPROVAL_BREAKCHECKS_NY)
+            ->willReturn(false);
+
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_BREAKCHECKS_NY)
+            ->willReturn(false);
+
+        // Break time check should not be called
+        $this->breakTimeCheckToolGER->expects($this->never())
+            ->method('checkBreakTime');
+
+        $result = $this->service->enrichRowsWithErrors($rows);
+
+        $this->assertFalse($result[0]['hasErrors']);
+    }
+
+    /**
+     * Test categorizeRowsByWeek separates past, current, and future
+     */
+    public function testCategorizeRowsByWeekSeparatesCorrectly(): void
+    {
+        // Get the Monday of current week
+        $now = new DateTime('now');
+        $currentMonday = (clone $now)->modify('next monday')->modify('-1 week');
+        $nextMonday = (clone $now)->modify('next monday');
+
+        $pastDate = (clone $currentMonday)->modify('-7 days')->format('Y-m-d');
+        $currentDate = $currentMonday->format('Y-m-d');
+        $futureDate = $nextMonday->format('Y-m-d');
+
+        $rows = [
+            ['userId' => 1, 'startDate' => $pastDate, 'status' => ApprovalStatus::SUBMITTED],
+            ['userId' => 2, 'startDate' => $currentDate, 'status' => ApprovalStatus::NOT_SUBMITTED],
+            ['userId' => 3, 'startDate' => $futureDate, 'status' => ApprovalStatus::NOT_SUBMITTED],
+        ];
+
+        [$pastRows, $currentRows, $futureRows] = $this->service->categorizeRowsByWeek($rows);
+
+        $this->assertCount(1, $pastRows);
+        $this->assertCount(1, $currentRows);
+        $this->assertCount(1, $futureRows);
+
+        $this->assertEquals($pastDate, $pastRows[0]['startDate']);
+        $this->assertEquals($currentDate, $currentRows[0]['startDate']);
+        $this->assertEquals($futureDate, $futureRows[0]['startDate']);
+    }
+
+    /**
+     * Test categorizeRowsByWeek with all past weeks
+     */
+    public function testCategorizeRowsByWeekAllPast(): void
+    {
+        $rows = [
+            ['userId' => 1, 'startDate' => '2026-01-06', 'status' => ApprovalStatus::SUBMITTED],
+            ['userId' => 2, 'startDate' => '2025-12-30', 'status' => ApprovalStatus::APPROVED],
+        ];
+
+        [$pastRows, $currentRows, $futureRows] = $this->service->categorizeRowsByWeek($rows);
+
+        $this->assertEquals(2, count($pastRows));
+        $this->assertEquals(0, count($currentRows));
+        $this->assertEquals(0, count($futureRows));
+    }
+
+    /**
+     * Test categorizeRowsByWeek with empty rows
+     */
+    public function testCategorizeRowsByWeekWithEmptyRows(): void
+    {
+        $rows = [];
+
+        [$pastRows, $currentRows, $futureRows] = $this->service->categorizeRowsByWeek($rows);
+
+        $this->assertCount(0, $pastRows);
+        $this->assertCount(0, $currentRows);
+        $this->assertCount(0, $futureRows);
+    }
+
+    /**
+     * Test countSubmittedWeeks counts only submitted status
+     */
+    public function testCountSubmittedWeeksCountsCorrectly(): void
+    {
+        $rows = [
+            ['status' => ApprovalStatus::SUBMITTED],
+            ['status' => ApprovalStatus::APPROVED],
+            ['status' => ApprovalStatus::SUBMITTED],
+            ['status' => ApprovalStatus::NOT_SUBMITTED],
+            ['status' => ApprovalStatus::SUBMITTED],
+            ['status' => ApprovalStatus::DENIED],
+        ];
+
+        $count = $this->service->countSubmittedWeeks($rows);
+
+        $this->assertEquals(3, $count);
+    }
+
+    /**
+     * Test countSubmittedWeeks with no submitted weeks
+     */
+    public function testCountSubmittedWeeksWithNoSubmitted(): void
+    {
+        $rows = [
+            ['status' => ApprovalStatus::APPROVED],
+            ['status' => ApprovalStatus::NOT_SUBMITTED],
+            ['status' => ApprovalStatus::DENIED],
+        ];
+
+        $count = $this->service->countSubmittedWeeks($rows);
+
+        $this->assertEquals(0, $count);
+    }
+
+    /**
+     * Test countSubmittedWeeks with empty rows
+     */
+    public function testCountSubmittedWeeksWithEmptyRows(): void
+    {
+        $rows = [];
+
+        $count = $this->service->countSubmittedWeeks($rows);
+
+        $this->assertEquals(0, $count);
+    }
+
+    /**
+     * Test countSubmittedWeeks with malformed data
+     */
+    public function testCountSubmittedWeeksWithMalformedData(): void
+    {
+        $rows = [
+            ['status' => ApprovalStatus::SUBMITTED],
+            ['noStatus' => 'value'], // Missing status key
+            ['status' => ApprovalStatus::SUBMITTED],
+        ];
+
+        $count = $this->service->countSubmittedWeeks($rows);
+
+        $this->assertEquals(2, $count);
+    }
+
+    /**
+     * Test filterByUsers with empty selected users returns all rows
+     */
+    public function testFilterByUsersWithEmptySelection(): void
+    {
+        $rows = [
+            ['userId' => 1, 'user' => 'User1'],
+            ['userId' => 2, 'user' => 'User2'],
+        ];
+
+        $query = new ApprovalQuery();
+        $query->setUsers([]);
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($rows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, []);
+
+        $this->assertCount(2, $result);
+    }
+
+    /**
+     * Test filterByDateRange with null date range returns all rows
+     */
+    public function testFilterByDateRangeWithNullRange(): void
+    {
+        $rows = [
+            ['userId' => 1, 'week' => (object) ['value' => new DateTime('2026-01-20')]],
+            ['userId' => 2, 'week' => (object) ['value' => new DateTime('2026-01-27')]],
+        ];
+
+        $query = new ApprovalQuery();
+        $query->setDateRange(new DateRange()); // No begin or end set
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($rows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, []);
+
+        $this->assertCount(2, $result);
+    }
+
+    /**
+     * Test filterByStatus with empty status returns all rows
+     */
+    public function testFilterByStatusWithEmptySelection(): void
+    {
+        $rows = [
+            ['userId' => 1, 'status' => ApprovalStatus::SUBMITTED],
+            ['userId' => 2, 'status' => ApprovalStatus::APPROVED],
+        ];
+
+        $query = new ApprovalQuery();
+        $query->setStatus([]);
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($rows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, []);
+
+        $this->assertCount(2, $result);
+    }
+
+    /**
+     * Test multiple filters applied together
+     */
+    public function testMultipleFiltersAppliedTogether(): void
+    {
+        $user1 = $this->createMock(User::class);
+        $user1->method('getId')->willReturn(1);
+
+        $users = [$user1];
+        $query = new ApprovalQuery();
+        $query->setUsers([$user1]);
+        $query->setStatus([ApprovalStatus::SUBMITTED]);
+
+        $dateRange = new DateRange();
+        $dateRange->setBegin(new DateTime('2026-01-20'));
+        $dateRange->setEnd(new DateTime('2026-01-26'));
+        $query->setDateRange($dateRange);
+
+        $allRows = [
+            [
+                'userId' => 1,
+                'user' => 'User1',
+                'week' => (object) ['value' => new DateTime('2026-01-20')],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+            [
+                'userId' => 1,
+                'user' => 'User1',
+                'week' => (object) ['value' => new DateTime('2026-01-20')],
+                'status' => ApprovalStatus::APPROVED
+            ],
+            [
+                'userId' => 2,
+                'user' => 'User2',
+                'week' => (object) ['value' => new DateTime('2026-01-20')],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+            [
+                'userId' => 1,
+                'user' => 'User1',
+                'week' => (object) ['value' => new DateTime('2026-02-03')],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+        ];
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($allRows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, $users);
+
+        // Should only return rows matching: userId=1, status=submitted, and within date range
+        $this->assertCount(1, $result);
+        $filteredResult = array_values($result);
+        $this->assertEquals(1, $filteredResult[0]['userId']);
+        $this->assertEquals(ApprovalStatus::SUBMITTED, $filteredResult[0]['status']);
+        $this->assertEquals(
+            new DateTime('2026-01-20'),
+            $filteredResult[0]['week']->value
+        );
+    }
+
+    /**
+     * Test rowMatchesSearchTerm matches user name
+     */
+    public function testRowMatchesSearchTermMatchesUser(): void
+    {
+        $searchTerm = new \App\Utils\SearchTerm('john');
+
+        $query = new ApprovalQuery();
+        $query->setSearchTerm($searchTerm);
+
+        $rows = [
+            [
+                'userId' => 1,
+                'user' => 'John Doe',
+                'week' => (object) ['label' => 'Week 4'],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+        ];
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($rows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, []);
+
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test rowMatchesSearchTerm matches status
+     */
+    public function testRowMatchesSearchTermMatchesStatus(): void
+    {
+        $searchTerm = new \App\Utils\SearchTerm('submit');
+
+        $query = new ApprovalQuery();
+        $query->setSearchTerm($searchTerm);
+
+        $rows = [
+            [
+                'userId' => 1,
+                'user' => 'John Doe',
+                'week' => (object) ['label' => 'Week 4'],
+                'status' => ApprovalStatus::SUBMITTED
+            ],
+        ];
+
+        $this->approvalRepository->method('findAllWeek')
+            ->willReturn($rows);
+
+        $this->settingsTool->method('getBooleanConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->fetchAndFilterApprovalRows($query, []);
+
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * Test getTimesheetsForRow creates correct query
+     */
+    public function testGetTimesheetsForRowCreatesCorrectQuery(): void
+    {
+        $user = $this->createMock(User::class);
+        $user->method('getId')->willReturn(1);
+
+        $weekStart = new DateTime('2026-01-20');
+        $row = [
+            'userId' => 1,
+            'week' => (object) ['value' => $weekStart],
+        ];
+
+        $this->userRepository->expects($this->once())
+            ->method('find')
+            ->with(1)
+            ->willReturn($user);
+
+        $this->timesheetRepository->expects($this->once())
+            ->method('getTimesheetsForQuery')
+            ->with($this->callback(function (TimesheetQuery $query) use ($user) {
+                return $query->getUser() === $user &&
+                    $query->getOrder() === BaseQuery::ORDER_ASC;
+            }))
+            ->willReturn([]);
+
+        $this->settingsTool->method('isInConfiguration')
+            ->willReturn(false);
+        $this->settingsTool->method('getConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->enrichRowsWithErrors([$row]);
+
+        $this->assertArrayHasKey('hasErrors', $result[0]);
+        $this->assertFalse($result[0]['hasErrors']);
+    }
+}
diff --git a/Tests/Service/AutoApprovalServiceTest.php b/Tests/Service/AutoApprovalServiceTest.php
new file mode 100644
index 0000000..65b1aa3
--- /dev/null
+++ b/Tests/Service/AutoApprovalServiceTest.php
@@ -0,0 +1,430 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Tests\Service;
+
+use App\Entity\User;
+use App\Repository\Query\TimesheetQuery;
+use App\Repository\TimesheetRepository;
+use DateTime;
+use KimaiPlugin\ApprovalBundle\Entity\Approval;
+use KimaiPlugin\ApprovalBundle\Entity\ApprovalHistory;
+use KimaiPlugin\ApprovalBundle\Entity\ApprovalStatus;
+use KimaiPlugin\ApprovalBundle\Enumeration\ConfigEnum;
+use KimaiPlugin\ApprovalBundle\Repository\ApprovalRepository;
+use KimaiPlugin\ApprovalBundle\Service\AutoApprovalService;
+use KimaiPlugin\ApprovalBundle\Toolbox\BreakTimeCheckToolGER;
+use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+
+class AutoApprovalServiceTest extends TestCase
+{
+    private AutoApprovalService $service;
+    private MockObject|ApprovalRepository $approvalRepository;
+    private MockObject|TimesheetRepository $timesheetRepository;
+    private MockObject|BreakTimeCheckToolGER $breakTimeCheckToolGER;
+    private MockObject|SettingsTool $settingsTool;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->approvalRepository = $this->createMock(ApprovalRepository::class);
+        $this->timesheetRepository = $this->createMock(TimesheetRepository::class);
+        $this->breakTimeCheckToolGER = $this->createMock(BreakTimeCheckToolGER::class);
+        $this->settingsTool = $this->createMock(SettingsTool::class);
+
+        $this->service = new AutoApprovalService(
+            $this->approvalRepository,
+            $this->timesheetRepository,
+            $this->breakTimeCheckToolGER,
+            $this->settingsTool
+        );
+    }
+
+    /**
+     * Test processApprovals with empty array
+     */
+    public function testProcessApprovalsWithEmptyArray(): void
+    {
+        $result = $this->service->processApprovals([]);
+
+        $this->assertEquals(0, $result['successful']);
+        $this->assertEquals(0, $result['failed']);
+        $this->assertEmpty($result['processedApprovals']);
+    }
+
+    /**
+     * Test processApprovals with all successful approvals
+     */
+    public function testProcessApprovalsAllSuccessful(): void
+    {
+        $approvals = [
+            $this->createMockApproval(1),
+            $this->createMockApproval(2),
+        ];
+
+        // Mock repository to return valid approvals
+        $this->approvalRepository->method('checkLastStatus')
+            ->willReturnArgument(4);
+
+        // Mock no errors
+        $this->timesheetRepository->method('getTimesheetsForQuery')
+            ->willReturn([]);
+
+        $this->settingsTool->method('isInConfiguration')
+            ->willReturn(false);
+
+        $this->settingsTool->method('getConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->processApprovals($approvals);
+
+        $this->assertEquals(2, $result['successful']);
+        $this->assertEquals(0, $result['failed']);
+        $this->assertCount(2, $result['processedApprovals']);
+    }
+
+    /**
+     * Test processApprovals with some failures
+     */
+    public function testProcessApprovalsWithFailures(): void
+    {
+        $approval1 = $this->createMockApproval(1);
+        $approval2 = $this->createMockApproval(2);
+
+        $approvals = [$approval1, $approval2];
+
+        // First approval succeeds, second fails
+        $this->approvalRepository->method('checkLastStatus')
+            ->willReturnOnConsecutiveCalls($approval1, null);
+
+        $this->timesheetRepository->method('getTimesheetsForQuery')
+            ->willReturn([]);
+
+        $this->settingsTool->method('isInConfiguration')
+            ->willReturn(false);
+
+        $this->settingsTool->method('getConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->processApprovals($approvals);
+
+        $this->assertEquals(1, $result['successful']);
+        $this->assertEquals(1, $result['failed']);
+        $this->assertCount(1, $result['processedApprovals']);
+    }
+
+    /**
+     * Test processSingleApproval with valid approval
+     */
+    public function testProcessSingleApprovalSuccess(): void
+    {
+        $approval = $this->createMockApproval(1);
+
+        $this->approvalRepository->method('checkLastStatus')
+            ->willReturn($approval);
+
+        $this->timesheetRepository->method('getTimesheetsForQuery')
+            ->willReturn([]);
+
+        $this->settingsTool->method('isInConfiguration')
+            ->willReturn(false);
+
+        $this->settingsTool->method('getConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->processSingleApproval($approval);
+
+        $this->assertTrue($result['approved']);
+        $this->assertSame($approval, $result['approval']);
+        $this->assertEquals('Auto-approved successfully', $result['reason']);
+    }
+
+    /**
+     * Test processSingleApproval with invalid status
+     */
+    public function testProcessSingleApprovalInvalidStatus(): void
+    {
+        $approval = $this->createMockApproval(1);
+
+        $this->approvalRepository->method('checkLastStatus')
+            ->willReturn(null);
+
+        $result = $this->service->processSingleApproval($approval);
+
+        $this->assertFalse($result['approved']);
+        $this->assertNull($result['approval']);
+        $this->assertEquals('Invalid approval status', $result['reason']);
+    }
+
+    /**
+     * Test processSingleApproval with wrong status
+     */
+    public function testProcessSingleApprovalWrongStatus(): void
+    {
+        $approval = $this->createMockApprovalWithStatus(ApprovalStatus::APPROVED);
+
+        $this->approvalRepository->method('checkLastStatus')
+            ->willReturn($approval);
+
+        $result = $this->service->processSingleApproval($approval);
+
+        $this->assertFalse($result['approved']);
+        $this->assertSame($approval, $result['approval']);
+        $this->assertEquals('Not in submitted status', $result['reason']);
+    }
+
+    /**
+     * Test processSingleApproval with validation errors
+     */
+    public function testProcessSingleApprovalWithValidationErrors(): void
+    {
+        $approval = $this->createMockApproval(1);
+
+        $this->approvalRepository->method('checkLastStatus')
+            ->willReturn($approval);
+
+        $this->timesheetRepository->method('getTimesheetsForQuery')
+            ->willReturn([]);
+
+        // Mock break time errors
+        $this->settingsTool->method('isInConfiguration')
+            ->willReturn(true);
+
+        $this->settingsTool->method('getConfiguration')
+            ->willReturn(true);
+
+        $this->breakTimeCheckToolGER->method('checkBreakTime')
+            ->willReturn(['2026-01-20' => 'Break time violation']);
+
+        $result = $this->service->processSingleApproval($approval);
+
+        $this->assertFalse($result['approved']);
+        $this->assertSame($approval, $result['approval']);
+        $this->assertEquals('Timesheet validation errors found', $result['reason']);
+    }
+
+    /**
+     * Test getTimesheetsForApproval creates correct query
+     */
+    public function testGetTimesheetsForApprovalCreatesCorrectQuery(): void
+    {
+        $user = $this->createMock(User::class);
+        $approval = $this->createMockApproval(1);
+        $approval->method('getUser')->willReturn($user);
+
+        $startDate = new DateTime('2026-01-20');
+        $endDate = new DateTime('2026-01-26');
+
+        $approval->method('getStartDate')->willReturn($startDate);
+        $approval->method('getEndDate')->willReturn($endDate);
+
+        $this->timesheetRepository->expects($this->once())
+            ->method('getTimesheetsForQuery')
+            ->willReturn([]);
+
+        $result = $this->service->getTimesheetsForApproval($approval);
+
+        $this->assertIsArray($result);
+    }
+
+    /**
+     * Test getTimesheetsForApproval with actual timesheets
+     */
+    public function testGetTimesheetsForApprovalReturnsTimesheets(): void
+    {
+        $user = $this->createMock(User::class);
+        $approval = $this->createMockApproval(1);
+        $approval->method('getUser')->willReturn($user);
+
+        $startDate = new DateTime('2026-01-20');
+        $endDate = new DateTime('2026-01-26');
+
+        $approval->method('getStartDate')->willReturn($startDate);
+        $approval->method('getEndDate')->willReturn($endDate);
+
+        // Mock timesheets to return
+        $mockTimesheets = [
+            ['date' => '2026-01-20', 'hours' => 8],
+            ['date' => '2026-01-21', 'hours' => 8],
+        ];
+
+        $this->timesheetRepository->expects($this->once())
+            ->method('getTimesheetsForQuery')
+            ->willReturn($mockTimesheets);
+
+        $result = $this->service->getTimesheetsForApproval($approval);
+
+        $this->assertIsArray($result);
+        $this->assertCount(2, $result);
+    }
+
+    /**
+     * Test validateTimesheets with break checks enabled
+     */
+    public function testValidateTimesheetsWithBreakChecksEnabled(): void
+    {
+        $timesheets = [];
+        $expectedErrors = ['2026-01-20' => 'Error'];
+
+        $this->settingsTool->method('isInConfiguration')
+            ->with(ConfigEnum::APPROVAL_BREAKCHECKS_NY)
+            ->willReturn(true);
+
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_BREAKCHECKS_NY)
+            ->willReturn(true);
+
+        $this->breakTimeCheckToolGER->expects($this->once())
+            ->method('checkBreakTime')
+            ->with($timesheets)
+            ->willReturn($expectedErrors);
+
+        $result = $this->service->validateTimesheets($timesheets);
+
+        $this->assertEquals($expectedErrors, $result);
+    }
+
+    /**
+     * Test validateTimesheets with break checks disabled
+     */
+    public function testValidateTimesheetsWithBreakChecksDisabled(): void
+    {
+        $timesheets = [];
+
+        $this->settingsTool->method('isInConfiguration')
+            ->with(ConfigEnum::APPROVAL_BREAKCHECKS_NY)
+            ->willReturn(false);
+
+        $this->settingsTool->method('getConfiguration')
+            ->with(ConfigEnum::APPROVAL_BREAKCHECKS_NY)
+            ->willReturn(false);
+
+        $this->breakTimeCheckToolGER->expects($this->never())
+            ->method('checkBreakTime');
+
+        $result = $this->service->validateTimesheets($timesheets);
+
+        $this->assertEmpty($result);
+    }
+
+    /**
+     * Test processApprovals handles mixed results correctly
+     */
+    public function testProcessApprovalsMixedResults(): void
+    {
+        $approval1 = $this->createMockApproval(1);
+        $approval2 = $this->createMockApproval(2);
+        $approval3 = $this->createMockApproval(3);
+
+        $approvals = [$approval1, $approval2, $approval3];
+
+        // First succeeds, second fails (null), third succeeds
+        $this->approvalRepository->method('checkLastStatus')
+            ->willReturnOnConsecutiveCalls($approval1, null, $approval3);
+
+        $this->timesheetRepository->method('getTimesheetsForQuery')
+            ->willReturn([]);
+
+        $this->settingsTool->method('isInConfiguration')
+            ->willReturn(false);
+
+        $this->settingsTool->method('getConfiguration')
+            ->willReturn(false);
+
+        $result = $this->service->processApprovals($approvals);
+
+        $this->assertEquals(2, $result['successful']);
+        $this->assertEquals(1, $result['failed']);
+        $this->assertCount(2, $result['processedApprovals']);
+    }
+
+    /**
+     * Test processApprovals with break time errors on some approvals
+     */
+    public function testProcessApprovalsWithBreakTimeErrorsOnSome(): void
+    {
+        $approval1 = $this->createMockApproval(1);
+        $approval2 = $this->createMockApproval(2);
+
+        $approvals = [$approval1, $approval2];
+
+        $this->approvalRepository->method('checkLastStatus')
+            ->willReturnArgument(4);
+
+        $this->timesheetRepository->method('getTimesheetsForQuery')
+            ->willReturn([]);
+
+        $this->settingsTool->method('isInConfiguration')
+            ->willReturn(true);
+
+        $this->settingsTool->method('getConfiguration')
+            ->willReturn(true);
+
+        // First has errors, second doesn't
+        $this->breakTimeCheckToolGER->method('checkBreakTime')
+            ->willReturnOnConsecutiveCalls(
+                ['2026-01-20' => 'Error'],
+                []
+            );
+
+        $result = $this->service->processApprovals($approvals);
+
+        $this->assertEquals(1, $result['successful']);
+        $this->assertEquals(1, $result['failed']);
+    }
+
+    /**
+     * Helper method to create a mock approval
+     */
+    private function createMockApproval(int $id): MockObject|Approval
+    {
+        $approval = $this->createMock(Approval::class);
+        $approval->method('getId')->willReturn($id);
+
+        $user = $this->createMock(User::class);
+        $approval->method('getUser')->willReturn($user);
+
+        $startDate = new DateTime('2026-01-20');
+        $endDate = new DateTime('2026-01-26');
+        $approval->method('getStartDate')->willReturn($startDate);
+        $approval->method('getEndDate')->willReturn($endDate);
+
+        // Mock history with SUBMITTED status
+        $history = $this->createMock(ApprovalHistory::class);
+        $status = $this->createMock(ApprovalStatus::class);
+        $status->method('getName')->willReturn(ApprovalStatus::SUBMITTED);
+        $history->method('getStatus')->willReturn($status);
+
+        $approval->method('getHistory')->willReturn([$history]);
+
+        return $approval;
+    }
+
+    /**
+     * Helper method to create a mock approval with specific status
+     */
+    private function createMockApprovalWithStatus(string $statusName): MockObject|Approval
+    {
+        $approval = $this->createMock(Approval::class);
+
+        $user = $this->createMock(User::class);
+        $approval->method('getUser')->willReturn($user);
+
+        $startDate = new DateTime('2026-01-20');
+        $endDate = new DateTime('2026-01-26');
+        $approval->method('getStartDate')->willReturn($startDate);
+        $approval->method('getEndDate')->willReturn($endDate);
+
+        // Mock history with custom status
+        $history = $this->createMock(ApprovalHistory::class);
+        $status = $this->createMock(ApprovalStatus::class);
+        $status->method('getName')->willReturn($statusName);
+        $history->method('getStatus')->willReturn($status);
+
+        $approval->method('getHistory')->willReturn([$history]);
+
+        return $approval;
+    }
+}
diff --git a/Tests/Toolbox/BreakTimeCheckToolGERTest.php b/Tests/Toolbox/BreakTimeCheckToolGERTest.php
new file mode 100644
index 0000000..5961755
--- /dev/null
+++ b/Tests/Toolbox/BreakTimeCheckToolGERTest.php
@@ -0,0 +1,73 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Tests\Toolbox;
+
+use App\Entity\Customer;
+use App\Entity\Project;
+use App\Entity\Timesheet;
+use App\Entity\User;
+use DateTime;
+use KimaiPlugin\ApprovalBundle\Toolbox\BreakTimeCheckToolGER;
+use KimaiPlugin\ApprovalBundle\Toolbox\SettingsTool;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Symfony\Contracts\Translation\TranslatorInterface;
+
+class BreakTimeCheckToolGERTest extends TestCase
+{
+    private MockObject|TranslatorInterface $translator;
+    private MockObject|SettingsTool $settingsTool;
+    private BreakTimeCheckToolGER $tool;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->translator = $this->createMock(TranslatorInterface::class);
+        $this->translator->method('trans')->willReturnCallback(static fn(string $key) => $key);
+
+        $this->settingsTool = $this->createMock(SettingsTool::class);
+        $this->settingsTool->method('getConfiguration')->willReturn(null);
+
+        $this->tool = new BreakTimeCheckToolGER($this->translator, $this->settingsTool);
+    }
+
+    public function testCheckBreakTimeDetailsKeepsDayErrorsButScopesTimesheetErrors(): void
+    {
+        $timesheetOne = $this->createTimesheet('2026-03-03 08:00:00', '2026-03-03 11:00:00', 3 * 60 * 60);
+        $timesheetTwo = $this->createTimesheet('2026-03-03 11:15:00', '2026-03-03 14:30:00', (3 * 60 * 60) + (15 * 60));
+
+        $details = $this->tool->checkBreakTimeDetails([$timesheetOne, $timesheetTwo]);
+
+        $expectedErrors = [
+            'error.six_hours_without_stop_break',
+            'error.six_hours_without_break',
+        ];
+
+        $this->assertSame($expectedErrors, $details['days']['2026-03-03']);
+        $this->assertSame([], $details['timesheets'][spl_object_id($timesheetOne)]);
+        $this->assertSame($expectedErrors, $details['timesheets'][spl_object_id($timesheetTwo)]);
+        $this->assertSame($details['days'], $this->tool->checkBreakTime([$timesheetOne, $timesheetTwo]));
+    }
+
+    private function createTimesheet(string $begin, string $end, int $duration): Timesheet
+    {
+        $customer = $this->createMock(Customer::class);
+        $customer->method('getId')->willReturn(1);
+
+        $project = $this->createMock(Project::class);
+        $project->method('getCustomer')->willReturn($customer);
+
+        $user = $this->createMock(User::class);
+        $user->method('getId')->willReturn(42);
+
+        $timesheet = $this->createMock(Timesheet::class);
+        $timesheet->method('getBegin')->willReturn(new DateTime($begin));
+        $timesheet->method('getEnd')->willReturn(new DateTime($end));
+        $timesheet->method('getDuration')->willReturn($duration);
+        $timesheet->method('getProject')->willReturn($project);
+        $timesheet->method('getUser')->willReturn($user);
+
+        return $timesheet;
+    }
+}
\ No newline at end of file
diff --git a/Tests/Toolbox/WorkingTimeActToolGERTest.php b/Tests/Toolbox/WorkingTimeActToolGERTest.php
new file mode 100644
index 0000000..23acb4b
--- /dev/null
+++ b/Tests/Toolbox/WorkingTimeActToolGERTest.php
@@ -0,0 +1,373 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Tests\Toolbox;
+
+use App\Entity\Timesheet;
+use DateTime;
+use DateTimeInterface;
+use KimaiPlugin\ApprovalBundle\Toolbox\WorkingTimeActToolGER;
+use KimaiPlugin\WorkContractBundle\Repository\PublicHolidayRepository;
+use KimaiPlugin\WorkContractBundle\Entity\PublicHoliday;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+
+class WorkingTimeActToolGERTest extends TestCase
+{
+    private WorkingTimeActToolGER $tool;
+    private MockObject|PublicHolidayRepository $publicHolidayRepository;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->publicHolidayRepository = $this->createMock(PublicHolidayRepository::class);
+        $this->tool = new WorkingTimeActToolGER($this->publicHolidayRepository);
+    }
+
+    /**
+     * Test compliance when working exactly 8 hours per day (should be compliant)
+     */
+    public function testCheckComplianceWithExactly8HoursPerDay(): void
+    {
+        $periodStart = new DateTime('2026-01-05'); // Monday
+        $periodEnd = new DateTime('2026-01-16'); // Friday (2 weeks)
+
+        // Create 8 timesheets: Monday-Friday for 2 weeks, exactly 8 hours each
+        $timesheets = [
+            $this->createTimesheet('2026-01-05', 8 * 3600), // Mon Week 1
+            $this->createTimesheet('2026-01-06', 8 * 3600), // Tue
+            $this->createTimesheet('2026-01-07', 8 * 3600), // Wed
+            $this->createTimesheet('2026-01-08', 8 * 3600), // Thu
+            $this->createTimesheet('2026-01-09', 8 * 3600), // Fri
+            $this->createTimesheet('2026-01-12', 8 * 3600), // Mon Week 2
+            $this->createTimesheet('2026-01-13', 8 * 3600), // Tue
+            $this->createTimesheet('2026-01-14', 8 * 3600), // Wed
+        ];
+
+        // Mock no public holidays
+        $this->publicHolidayRepository->expects($this->once())
+            ->method('findHolidaysForPeriod')
+            ->willReturn([]);
+
+        $result = $this->tool->checkWorkingTimeActToolGERCompliance(
+            $timesheets,
+            1, // publicHolidayGroupId
+            $periodStart,
+            $periodEnd
+        );
+
+        // 2 weeks = 11 workdays (Mon-Fri, excluding weekends)
+        // Total hours: 8 timesheets * 8 hours = 64 hours
+        // Average: 64 / 11 hours/day
+        $this->assertTrue($result['compliance']);
+        $this->assertEquals(64.0, $result['total_hours']);
+        $this->assertEquals(11, $result['workdays']);
+        $this->assertEquals(64.0 / 11, $result['average']);
+    }
+
+    /**
+     * Test compliance with one Sunday (should be excluded from workdays)
+     */
+    public function testCheckComplianceExcludesSunday(): void
+    {
+        $periodStart = new DateTime('2026-01-05'); // Monday
+        $periodEnd = new DateTime('2026-01-11'); // Sunday
+
+        // Create 7 timesheets including a Sunday
+        $timesheets = [
+            $this->createTimesheet('2026-01-05', 8 * 3600), // Mon
+            $this->createTimesheet('2026-01-06', 8 * 3600), // Tue
+            $this->createTimesheet('2026-01-07', 8 * 3600), // Wed
+            $this->createTimesheet('2026-01-08', 8 * 3600), // Thu
+            $this->createTimesheet('2026-01-09', 8 * 3600), // Fri
+            $this->createTimesheet('2026-01-10', 6 * 3600), // Sat
+            $this->createTimesheet('2026-01-11', 5 * 3600), // Sun (should be excluded)
+        ];
+
+        $this->publicHolidayRepository->expects($this->once())
+            ->method('findHolidaysForPeriod')
+            ->willReturn([]);
+
+        $result = $this->tool->checkWorkingTimeActToolGERCompliance(
+            $timesheets,
+            1,
+            $periodStart,
+            $periodEnd
+        );
+
+        // Workdays: Mon-Sat = 6 days (Sunday excluded)
+        // Total: 8+8+8+8+8+6 = 46 hours (Sunday's 5 hours not counted)
+        // Average: 46 / 6 = 7.67 hours/day
+        $this->assertTrue($result['compliance']);
+        $this->assertEquals(7.666666666666667, $result['average']);
+        $this->assertEquals(46.0, $result['total_hours']);
+        $this->assertEquals(6, $result['workdays']);
+    }
+
+    /**
+     * Test compliance with public holidays (should be excluded)
+     */
+    public function testCheckComplianceExcludesPublicHolidays(): void
+    {
+        $periodStart = new DateTime('2026-01-05'); // Monday
+        $periodEnd = new DateTime('2026-01-16'); // Friday
+
+        // Create 8 timesheets
+        $timesheets = [
+            $this->createTimesheet('2026-01-05', 8 * 3600), // Mon
+            $this->createTimesheet('2026-01-06', 8 * 3600), // Tue (Public Holiday)
+            $this->createTimesheet('2026-01-07', 8 * 3600), // Wed
+            $this->createTimesheet('2026-01-08', 8 * 3600), // Thu
+            $this->createTimesheet('2026-01-09', 8 * 3600), // Fri
+            $this->createTimesheet('2026-01-12', 8 * 3600), // Mon
+            $this->createTimesheet('2026-01-13', 8 * 3600), // Tue (Public Holiday)
+            $this->createTimesheet('2026-01-14', 8 * 3600), // Wed
+        ];
+
+        // Mock two public holidays: 2026-01-06 and 2026-01-13
+        $holiday1 = $this->createMock(PublicHoliday::class);
+        $holiday1->method('getDate')->willReturn(new \DateTimeImmutable('2026-01-06'));
+
+        $holiday2 = $this->createMock(PublicHoliday::class);
+        $holiday2->method('getDate')->willReturn(new \DateTimeImmutable('2026-01-13'));
+
+        $this->publicHolidayRepository->expects($this->once())
+            ->method('findHolidaysForPeriod')
+            ->willReturn([$holiday1, $holiday2]);
+
+        $result = $this->tool->checkWorkingTimeActToolGERCompliance(
+            $timesheets,
+            1,
+            $periodStart,
+            $periodEnd
+        );
+
+        // 11 weekdays - 2 holidays = 9 workdays
+        // Total: 48 hours, but holidays excluded from count
+        // Average: 48 / 9  hours/day
+        $this->assertTrue($result['compliance']);
+        $this->assertEquals(48.0, $result['total_hours']);
+        $this->assertEquals(9, $result['workdays']);
+        $this->assertEquals(48.0 / 9, $result['average']);
+    }
+
+    /**
+     * Test non-compliance when average exceeds 8 hours per day
+     */
+    public function testCheckComplianceWithExcessiveHours(): void
+    {
+        $periodStart = new DateTime('2026-01-05'); // Monday
+        $periodEnd = new DateTime('2026-01-09'); // Friday
+
+        // Create 7 timesheets with excessive hours
+        $timesheets = [
+            $this->createTimesheet('2026-01-05', 10 * 3600), // Mon
+            $this->createTimesheet('2026-01-06', 10 * 3600), // Tue
+            $this->createTimesheet('2026-01-07', 9 * 3600),  // Wed
+            $this->createTimesheet('2026-01-08', 10 * 3600), // Thu
+            $this->createTimesheet('2026-01-09', 10 * 3600), // Fri
+            $this->createTimesheet('2026-01-10', 6 * 3600),  // Sat
+            $this->createTimesheet('2026-01-11', 5 * 3600),  // Sun (excluded)
+        ];
+
+        $this->publicHolidayRepository->expects($this->once())
+            ->method('findHolidaysForPeriod')
+            ->willReturn([]);
+
+        $result = $this->tool->checkWorkingTimeActToolGERCompliance(
+            $timesheets,
+            1,
+            $periodStart,
+            $periodEnd
+        );
+
+        // Workdays: Mon-Sat = 6 days
+        // Total: 10+10+9+10+10 = 49 hours
+        // Average: 49 / 5 = 9.8 hours/day (exceeds 8 hours)
+        $this->assertFalse($result['compliance']);
+        $this->assertEquals(49.0, $result['total_hours']);
+        $this->assertEquals(5, $result['workdays']);
+        $this->assertEquals(49.0 / 5, $result['average']);
+    }
+
+    /**
+     * Test empty workdays are counted with 0 hours
+     */
+    public function testCheckComplianceWithEmptyWorkdays(): void
+    {
+        $periodStart = new DateTime('2026-01-05'); // Monday
+        $periodEnd = new DateTime('2026-01-16'); // Friday (2 weeks)
+
+        // Create only 5 timesheets (1 week of work, 1 week empty)
+        $timesheets = [
+            $this->createTimesheet('2026-01-05', 8 * 3600), // Mon Week 1
+            $this->createTimesheet('2026-01-06', 8 * 3600), // Tue
+            $this->createTimesheet('2026-01-07', 8 * 3600), // Wed
+            $this->createTimesheet('2026-01-08', 8 * 3600), // Thu
+            $this->createTimesheet('2026-01-09', 8 * 3600), // Fri
+            // Week 2: No timesheets (empty workdays)
+        ];
+
+        $this->publicHolidayRepository->expects($this->once())
+            ->method('findHolidaysForPeriod')
+            ->willReturn([]);
+
+        $result = $this->tool->checkWorkingTimeActToolGERCompliance(
+            $timesheets,
+            1,
+            $periodStart,
+            $periodEnd
+        );
+
+        // 10 workdays total (2 weeks Mon-Fri)
+        // Total: 40 hours (only first week)
+        // Average: 40 / 11 hours/day (empty days count as 0)
+        $this->assertTrue($result['compliance']);
+        $this->assertEquals(40.0, $result['total_hours']);
+        $this->assertEquals(11, $result['workdays']);
+        $this->assertEquals(40.0 / 11, $result['average']);
+    }
+
+    /**
+     * Test compliance with mixed scenario: Sunday, holidays, empty days
+     */
+    public function testCheckComplianceWithMixedScenario(): void
+    {
+        $periodStart = new DateTime('2026-01-05'); // Monday
+        $periodEnd = new DateTime('2026-01-18'); // Sunday (2 weeks)
+
+        // Create 8 timesheets with varied hours
+        $timesheets = [
+            $this->createTimesheet('2026-01-05', 7 * 3600),  // Mon
+            $this->createTimesheet('2026-01-06', 9 * 3600),  // Tue (Public Holiday - excluded)
+            $this->createTimesheet('2026-01-07', 8 * 3600),  // Wed
+            $this->createTimesheet('2026-01-08', 7.5 * 3600), // Thu
+            // 2026-01-09 Fri - Empty workday
+            $this->createTimesheet('2026-01-10', 6 * 3600),  // Sat
+            $this->createTimesheet('2026-01-11', 5 * 3600),  // Sun (excluded)
+            $this->createTimesheet('2026-01-12', 8 * 3600),  // Mon
+            $this->createTimesheet('2026-01-13', 8 * 3600),  // Tue (Public Holiday - excluded)
+            // Rest of week 2 empty
+        ];
+
+        // Mock two public holidays
+        $holiday1 = $this->createMock(PublicHoliday::class);
+        $holiday1->method('getDate')->willReturn(new \DateTimeImmutable('2026-01-06'));
+
+        $holiday2 = $this->createMock(PublicHoliday::class);
+        $holiday2->method('getDate')->willReturn(new \DateTimeImmutable('2026-01-13'));
+
+        $this->publicHolidayRepository->expects($this->once())
+            ->method('findHolidaysForPeriod')
+            ->willReturn([$holiday1, $holiday2]);
+
+        $result = $this->tool->checkWorkingTimeActToolGERCompliance(
+            $timesheets,
+            1,
+            $periodStart,
+            $periodEnd
+        );
+
+        // 2 weeks = 14 days total
+        // - 2 Sundays (Jan 11, 18) = 12 days
+        // - 2 holidays (Jan 6, 13) = 10 workdays
+        // Total hours: 7+8+7.5+6+8 = 53.5 (holidays counted in total)
+        // Average: 36.5 / 10 = 5.35 hours/day
+        $this->assertTrue($result['compliance']);
+        $this->assertEquals(36.5, $result['total_hours']);
+        $this->assertEquals(10, $result['workdays']);
+        $this->assertEquals(36.5 / 10, $result['average']);
+    }
+
+    /**
+     * Test without public holiday repository (null)
+     */
+    public function testCheckComplianceWithoutPublicHolidayRepository(): void
+    {
+        $tool = new WorkingTimeActToolGER(null);
+
+        $periodStart = new DateTime('2026-01-05'); // Monday
+        $periodEnd = new DateTime('2026-01-09'); // Friday
+
+        $timesheets = [
+            $this->createTimesheet('2026-01-05', 8 * 3600), // Mon
+            $this->createTimesheet('2026-01-06', 8 * 3600), // Tue
+            $this->createTimesheet('2026-01-07', 8 * 3600), // Wed
+            $this->createTimesheet('2026-01-08', 8 * 3600), // Thu
+            $this->createTimesheet('2026-01-09', 8 * 3600), // Fri
+        ];
+
+        $result = $tool->checkWorkingTimeActToolGERCompliance(
+            $timesheets,
+            null, // No public holiday group
+            $periodStart,
+            $periodEnd
+        );
+
+        // Should work without public holidays
+        $this->assertTrue($result['compliance']);
+        $this->assertEquals(8.0, $result['average']);
+        $this->assertEquals(40.0, $result['total_hours']);
+        $this->assertEquals(5, $result['workdays']);
+    }
+
+    /**
+     * Test with invalid period (start after end) should throw exception
+     */
+    public function testCheckComplianceWithInvalidPeriodThrowsException(): void
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('Period start must be before period end');
+
+        $periodStart = new DateTime('2026-01-16');
+        $periodEnd = new DateTime('2026-01-05');
+
+        $this->tool->checkWorkingTimeActToolGERCompliance(
+            [],
+            null,
+            $periodStart,
+            $periodEnd
+        );
+    }
+
+    /**
+     * Test with no timesheets (all empty days)
+     */
+    public function testCheckComplianceWithNoTimesheets(): void
+    {
+        $periodStart = new DateTime('2026-01-05'); // Monday
+        $periodEnd = new DateTime('2026-01-09'); // Friday
+
+        $this->publicHolidayRepository->expects($this->once())
+            ->method('findHolidaysForPeriod')
+            ->willReturn([]);
+
+        $result = $this->tool->checkWorkingTimeActToolGERCompliance(
+            [], // No timesheets
+            1,
+            $periodStart,
+            $periodEnd
+        );
+
+        // 5 workdays, 0 hours
+        // Average: 0 / 5 = 0 hours/day
+        $this->assertTrue($result['compliance']);
+        $this->assertEquals(0.0, $result['average']);
+        $this->assertEquals(0.0, $result['total_hours']);
+        $this->assertEquals(5, $result['workdays']);
+    }
+
+    /**
+     * Helper method to create a mock timesheet
+     */
+    private function createTimesheet(string $date, int $durationSeconds): Timesheet
+    {
+        $timesheet = $this->createMock(Timesheet::class);
+
+        $dateTime = new DateTime($date . ' 09:00:00');
+        $timesheet->method('getBegin')->willReturn($dateTime);
+        $timesheet->method('getDuration')->willReturn($durationSeconds);
+
+        return $timesheet;
+    }
+}
diff --git a/Toolbox/BreakTimeCheckToolGER.php b/Toolbox/BreakTimeCheckToolGER.php
index e11a44a..d9acd1b 100644
--- a/Toolbox/BreakTimeCheckToolGER.php
+++ b/Toolbox/BreakTimeCheckToolGER.php
@@ -21,11 +21,23 @@ public function __construct(private TranslatorInterface $translator, private Set
 
     /**
      * @param array<Timesheet> $timesheets
-     * @return array
+     * @return array<string, array<int, string>>
      */
     public function checkBreakTime(array $timesheets): array
     {
-        $errors = [];
+        return $this->checkBreakTimeDetails($timesheets)['days'];
+    }
+
+    /**
+     * @param array<Timesheet> $timesheets
+     * @return array{days: array<string, array<int, string>>, timesheets: array<int, array<int, string>>}
+     */
+    public function checkBreakTimeDetails(array $timesheets): array
+    {
+        $errors = [
+            'days' => [],
+            'timesheets' => [],
+        ];
 
         $customerId = (int) $this->settingsTool->getConfiguration(ConfigEnum::CUSTOMER_FOR_FREE_DAYS, null);
         if ($customerId !== null) {
@@ -55,29 +67,25 @@ function (Timesheet $timesheet) use ($customerId) {
         return $this->addEmptyErrorsDays($timesheets, $errors);
     }
 
-    private function checkOffdayWork($timesheets, &$errors, $offdays)
+    private function checkOffdayWork(array $timesheets, array &$errors, array $offdays): void
     {
         foreach ($timesheets as $timesheet) {
-            if (
-                \in_array($timesheet->getBegin()->format('Y-m-d'), $offdays) &&
-                ($errors[$timesheet->getBegin()->format('Y-m-d')] == null ||
-                    \in_array($this->translator->trans('error.work_offdays'), $errors[$timesheet->getBegin()->format('Y-m-d')]) == false)
-            ) {
-                $errors[$timesheet->getBegin()->format('Y-m-d')][] = $this->translator->trans('error.work_offdays');
+            if (\in_array($timesheet->getBegin()->format('Y-m-d'), $offdays, true)) {
+                $this->addError($errors, $timesheet, $this->translator->trans('error.work_offdays'));
             }
         }
     }
 
-    private function checkSundayWork($timesheets, &$errors)
+    private function checkSundayWork(array $timesheets, array &$errors): void
     {
         foreach ($timesheets as $timesheet) {
             if ($timesheet->getBegin()->format('w') == 0) {
-                $errors[$timesheet->getBegin()->format('Y-m-d')][] = $this->translator->trans('error.work_on_sunday');
+                $this->addError($errors, $timesheet, $this->translator->trans('error.work_on_sunday'));
             }
         }
     }
 
-    private function checkSixHoursWithoutBreak($timesheets, &$errors)
+    private function checkSixHoursWithoutBreak(array $timesheets, array &$errors): void
     {
         $sixHoursInSeconds = 6 * 60 * 60;
         $thirtyMinutesBreakInSeconds = 30 * 60;
@@ -101,17 +109,12 @@ private function checkSixHoursWithoutBreak($timesheets, &$errors)
             }
             $blockEnd = $timesheet->getEnd()->getTimestamp();
             if ($blockEnd - $blockStart > $sixHoursInSeconds) {
-                if (
-                    array_key_exists($timesheet->getBegin()->format('Y-m-d'), $errors) && ($errors[$timesheet->getBegin()->format('Y-m-d')] == null ||
-                        \in_array($this->translator->trans('error.six_hours_without_stop_break'), $errors[$timesheet->getBegin()->format('Y-m-d')]) == false)
-                ) {
-                    $errors[$timesheet->getBegin()->format('Y-m-d')][] = $this->translator->trans('error.six_hours_without_stop_break');
-                }
+                $this->addError($errors, $timesheet, $this->translator->trans('error.six_hours_without_stop_break'));
             }
         }
     }
 
-    private function checkSixHoursAndBreak($timesheets, &$errors)
+    private function checkSixHoursAndBreak(array $timesheets, array &$errors): void
     {
         $sixHoursInSeconds = 6 * 60 * 60;
         $thirtyMinutesBreakInSeconds = 30 * 60;
@@ -119,7 +122,7 @@ private function checkSixHoursAndBreak($timesheets, &$errors)
         $this->checkHoursBreak($sixHoursInSeconds, $thirtyMinutesBreakInSeconds, 'error.six_hours_without_break', $timesheets, $errors);
     }
 
-    private function checkHoursBreak($hoursInSeconds, $breakInSeconds, $translationKey, $timesheets, &$errors)
+    private function checkHoursBreak(int $hoursInSeconds, int $breakInSeconds, string $translationKey, array $timesheets, array &$errors): void
     {
         $minDurationForBreak = 15 * 60;
         $result = [];
@@ -150,14 +153,14 @@ private function checkHoursBreak($hoursInSeconds, $breakInSeconds, $translationK
 
                 if ($result[$hash]['duration'] > $hoursInSeconds) {
                     if ($result[$hash]['breakDuration'] < $breakInSeconds) {
-                        $errors[$timesheet->getBegin()->format('Y-m-d')][] = $this->translator->trans($translationKey);
+                        $this->addError($errors, $timesheet, $this->translator->trans($translationKey));
                     }
                 }
             }
         }
     }
 
-    private function checkNineHoursWithoutBreak($timesheets, &$errors)
+    private function checkNineHoursWithoutBreak(array $timesheets, array &$errors): void
     {
         $nineHoursInSeconds = 9 * 60 * 60;
         $fortyFiveMinutesBreakInSeconds = 45 * 60;
@@ -165,7 +168,7 @@ private function checkNineHoursWithoutBreak($timesheets, &$errors)
         $this->checkHoursBreak($nineHoursInSeconds, $fortyFiveMinutesBreakInSeconds, 'error.nine_hours_without_break', $timesheets, $errors);
     }
 
-    private function checkMoreThanTenHours($timesheets, &$errors)
+    private function checkMoreThanTenHours(array $timesheets, array &$errors): void
     {
         $tenHoursInSeconds = 10 * 60 * 60;
         $result = [];
@@ -180,7 +183,7 @@ private function checkMoreThanTenHours($timesheets, &$errors)
             }
 
             if ($result[$hash]['duration'] > $tenHoursInSeconds) {
-                $errors[$timesheet->getBegin()->format('Y-m-d')][] = $this->translator->trans('error.more_than_ten_hours_worked');
+                $this->addError($errors, $timesheet, $this->translator->trans('error.more_than_ten_hours_worked'));
             }
         }
     }
@@ -193,7 +196,7 @@ function ($result, Timesheet $timesheet) {
                 if (\array_key_exists($timesheet->getUser()->getId(), $result)) {
                     $result[$timesheet->getUser()->getId()][] = $timesheet;
                 } else {
-                    $result[$timesheet->getUser()->getId()] = [];
+                    $result[$timesheet->getUser()->getId()] = [$timesheet];
                 }
 
                 return $result;
@@ -210,10 +213,10 @@ function ($result, Timesheet $timesheet) {
                     $timesheetOne = $value[$i]->getEnd()->getTimestamp();
                     $timesheetTwo = $value[$i + 1]->getBegin()->getTimestamp();
                     if ($value[$i]->getEnd() == null) {
-                        $errors[$value[$i + 1]->getBegin()->format('Y-m-d')][] = $this->translator->trans('error.no_end_date');
+                        $this->addError($errors, $value[$i + 1], $this->translator->trans('error.no_end_date'));
                     }
                     if (abs($timesheetOne - $timesheetTwo) < 11 * 60 * 60 && $value[$i]->getEnd()->format('Y-m-d') < $value[$i + 1]->getEnd()->format('Y-m-d')) {    // 11h * 60 * 60 -> to seconds
-                        $errors[$value[$i + 1]->getBegin()->format('Y-m-d')][] = $this->translator->trans('error.less_than_eleven_hours_off');
+                        $this->addError($errors, $value[$i + 1], $this->translator->trans('error.less_than_eleven_hours_off'));
                     }
                 }
             }
@@ -223,16 +226,44 @@ function ($result, Timesheet $timesheet) {
     /**
      * @param array $timesheets
      * @param array $errors
-     * @return array
+     * @return array{days: array<string, array<int, string>>, timesheets: array<int, array<int, string>>}
      */
     protected function addEmptyErrorsDays(array $timesheets, array $errors): array
     {
         foreach ($timesheets as $timesheet) {
-            if (!\array_key_exists($timesheet->getBegin()->format('Y-m-d'), $errors)) {
-                $errors[$timesheet->getBegin()->format('Y-m-d')] = [];
-            }
+            $this->initializeErrorEntries($errors, $timesheet);
         }
 
         return $errors;
     }
+
+    private function addError(array &$errors, Timesheet $timesheet, string $message): void
+    {
+        $this->initializeErrorEntries($errors, $timesheet);
+
+        $date = $timesheet->getBegin()->format('Y-m-d');
+        $timesheetId = spl_object_id($timesheet);
+
+        if (!\in_array($message, $errors['days'][$date], true)) {
+            $errors['days'][$date][] = $message;
+        }
+
+        if (!\in_array($message, $errors['timesheets'][$timesheetId], true)) {
+            $errors['timesheets'][$timesheetId][] = $message;
+        }
+    }
+
+    private function initializeErrorEntries(array &$errors, Timesheet $timesheet): void
+    {
+        $date = $timesheet->getBegin()->format('Y-m-d');
+        $timesheetId = spl_object_id($timesheet);
+
+        if (!\array_key_exists($date, $errors['days'])) {
+            $errors['days'][$date] = [];
+        }
+
+        if (!\array_key_exists($timesheetId, $errors['timesheets'])) {
+            $errors['timesheets'][$timesheetId] = [];
+        }
+    }
 }
diff --git a/Toolbox/SettingsTool.php b/Toolbox/SettingsTool.php
index c5824ec..3dd6a26 100644
--- a/Toolbox/SettingsTool.php
+++ b/Toolbox/SettingsTool.php
@@ -35,6 +35,11 @@ public function isOvertimeCheckActive(): bool
         return $this->getConfiguration(ConfigEnum::APPROVAL_OVERTIME_NY, '1') !== '0';
     }
 
+    public function isBreakTimeCheckActive(): bool
+    {
+        return $this->getConfiguration(ConfigEnum::APPROVAL_BREAKCHECKS_NY, '1') !== '0';
+    }
+
     public function getBooleanConfiguration(string $key, bool $default = false): bool
     {
         return $this->getConfiguration($key, $default ? '1' : '0') === '1';
diff --git a/Toolbox/WorkingTimeActToolGER.php b/Toolbox/WorkingTimeActToolGER.php
new file mode 100644
index 0000000..ec0e9ab
--- /dev/null
+++ b/Toolbox/WorkingTimeActToolGER.php
@@ -0,0 +1,258 @@
+<?php
+
+namespace KimaiPlugin\ApprovalBundle\Toolbox;
+
+use DateTime;
+use DateInterval;
+use DateTimeInterface;
+use App\Entity\User;
+use KimaiPlugin\WorkContractBundle\Repository\PublicHolidayRepository;
+
+/**
+ * German Arbeitszeitgesetz (ArbZG) - Working Time Act compliance checker
+ * 
+ * § 3 ArbZG: "Die werktägliche Arbeitszeit der Arbeitnehmer darf acht Stunden nicht überschreiten. 
+ * Sie kann auf bis zu zehn Stunden nur verlängert werden, wenn innerhalb von sechs Kalendermonaten 
+ * oder innerhalb von 24 Wochen im Durchschnitt acht Stunden werktäglich nicht überschritten werden."
+ * 
+ * Translation: Daily working time must not exceed 8 hours. It can be extended to 10 hours only if 
+ * within 6 calendar months or 24 weeks, the average daily working time does not exceed 8 hours.
+ */
+class WorkingTimeActToolGER
+{
+    private const MAX_DAILY_HOURS = 8;
+    private const SECONDS_PER_HOUR = 3600;
+    private const SUNDAY = 7;
+
+    public function __construct(
+        private ?PublicHolidayRepository $publicHolidayRepository = null
+    ) {
+    }
+
+    /**
+     * Check if timesheets comply with ArbZG regulations
+     * 
+     * @param array $timesheets Array of Timesheet entities
+     * @param int|null $publicHolidayGroupId Public holiday group ID from user
+     * @param DateTimeInterface $periodStart Start of period to check
+     * @param DateTimeInterface $periodEnd End of period to check
+     * 
+     * @return array{
+     *     'compliance': bool,
+     *     'average': float,
+     *     'total_hours': float,
+     *     'workdays': int,
+     *     'period_start': DateTimeInterface,
+     *     'period_end': DateTimeInterface
+     * }
+     */
+    public function checkWorkingTimeActToolGERCompliance(
+        array $timesheets,
+        ?int $publicHolidayGroupId,
+        DateTimeInterface $periodStart,
+        DateTimeInterface $periodEnd
+    ): array {
+        // Validate input
+        if ($periodStart > $periodEnd) {
+            throw new \InvalidArgumentException('Period start must be before period end');
+        }
+
+        // Get all working days (excluding weekends and holidays)
+        $workingDays = $this->getWorkingDaysInPeriod(
+            $periodStart,
+            $periodEnd,
+            $publicHolidayGroupId
+        );
+
+        // Get daily hours grouped by date
+        $dailyHours = $this->groupTimesheetsByDay($timesheets);
+
+        // Calculate totals
+        $totalHours = $this->sumHoursForWorkingDays($dailyHours, $workingDays);
+        $workdayCount = count($workingDays);
+
+        // Calculate average hours per working day
+        $average = $workdayCount > 0 ? $totalHours / $workdayCount : 0;
+
+        return [
+            'compliance' => $average <= self::MAX_DAILY_HOURS,
+            'average' => $average,
+            'total_hours' => $totalHours,
+            'workdays' => $workdayCount,
+            'period_start' => $periodStart,
+            'period_end' => $periodEnd
+        ];
+    }
+
+    /**
+     * Get all working days in a period (excludes weekends and public holidays)
+     * 
+     * @param DateTimeInterface $periodStart
+     * @param DateTimeInterface $periodEnd
+     * @param int|null $publicHolidayGroupId
+     * @return array<string> Array of working dates in format 'Y-m-d'
+     */
+    private function getWorkingDaysInPeriod(
+        DateTimeInterface $periodStart,
+        DateTimeInterface $periodEnd,
+        ?int $publicHolidayGroupId
+    ): array {
+        $allDays = $this->getAllDaysInPeriod($periodStart, $periodEnd);
+        $publicHolidays = $this->fetchPublicHolidays($periodStart, $periodEnd, $publicHolidayGroupId);
+
+        return array_filter($allDays, function (string $date) use ($publicHolidays) {
+            return $this->isWorkingDay($date, $publicHolidays);
+        });
+    }
+
+    /**
+     * Get all days in a period (including weekends)
+     * 
+     * @param DateTimeInterface $start
+     * @param DateTimeInterface $end
+     * @return array<string> Array of dates in format 'Y-m-d'
+     */
+    private function getAllDaysInPeriod(DateTimeInterface $start, DateTimeInterface $end): array
+    {
+        $days = [];
+        $current = (new DateTime())->setTimestamp($start->getTimestamp());
+        $end = (new DateTime())->setTimestamp($end->getTimestamp());
+
+        while ($current <= $end) {
+            $days[] = $current->format('Y-m-d');
+            $current->add(new DateInterval('P1D'));
+        }
+
+        return $days;
+    }
+
+    /**
+     * Fetch public holidays for period from WorkContractBundle if available
+     * 
+     * @param DateTimeInterface $periodStart
+     * @param DateTimeInterface $periodEnd
+     * @param int|null $publicHolidayGroupId
+     * @return array<string> Array of holiday dates in format 'Y-m-d'
+     */
+    private function fetchPublicHolidays(
+        DateTimeInterface $periodStart,
+        DateTimeInterface $periodEnd,
+        ?int $publicHolidayGroupId
+    ): array {
+        if (!$publicHolidayGroupId || !$this->isWorkContractBundleAvailable()) {
+            return [];
+        }
+
+        try {
+            $holidays = $this->publicHolidayRepository->findHolidaysForPeriod(
+                $periodStart,
+                $periodEnd,
+                $publicHolidayGroupId
+            );
+
+            return array_map(
+                fn($holiday) => $holiday->getDate()->format('Y-m-d'),
+                $holidays
+            );
+        } catch (\Exception $e) {
+            // Log or handle error gracefully
+            return [];
+        }
+    }
+
+    /**
+     * Check if a single date is a working day
+     * 
+     * @param string $date Date in format 'Y-m-d'
+     * @param array<string> $publicHolidays Array of public holiday dates
+     * @return bool True if working day
+     */
+    private function isWorkingDay(string $date, array $publicHolidays): bool
+    {
+        $dayOfWeek = (int) (new DateTime($date))->format('N');
+
+        // Not a sunday
+        if ($dayOfWeek === self::SUNDAY) {
+            return false;
+        }
+
+        // Not a public holiday
+        return !in_array($date, $publicHolidays, true);
+    }
+
+    /**
+     * Group timesheets by day and sum hours
+     * 
+     * @param array $timesheets Array of Timesheet entities
+     * @return array<string, float> ['YYYY-MM-DD' => hours]
+     */
+    private function groupTimesheetsByDay(array $timesheets): array
+    {
+        $dailyHours = [];
+
+        foreach ($timesheets as $timesheet) {
+            $dateStr = $this->extractDateFromTimesheet($timesheet);
+            if ($dateStr === null) {
+                continue;
+            }
+
+            $hours = $this->convertDurationToHours($timesheet->getDuration() ?? 0);
+            $dailyHours[$dateStr] = ($dailyHours[$dateStr] ?? 0) + $hours;
+        }
+
+        return $dailyHours;
+    }
+
+    /**
+     * Extract date from timesheet entity
+     * 
+     * @param mixed $timesheet Timesheet entity
+     * @return string|null Date in format 'Y-m-d' or null if invalid
+     */
+    private function extractDateFromTimesheet($timesheet): ?string
+    {
+        $dateObj = $timesheet->getBegin() ?? $timesheet->getDate() ?? null;
+
+        return $dateObj ? $dateObj->format('Y-m-d') : null;
+    }
+
+    /**
+     * Convert duration in seconds to hours
+     * 
+     * @param int $durationSeconds Duration in seconds
+     * @return float Duration in hours
+     */
+    private function convertDurationToHours(int $durationSeconds): float
+    {
+        return $durationSeconds / self::SECONDS_PER_HOUR;
+    }
+
+    /**
+     * Sum hours for all working days (including empty days as 0 hours)
+     * 
+     * @param array<string, float> $dailyHours Grouped daily hours
+     * @param array<string> $workingDays Working days in period
+     * @return float Total hours worked
+     */
+    private function sumHoursForWorkingDays(array $dailyHours, array $workingDays): float
+    {
+        $totalHours = 0;
+
+        foreach ($workingDays as $date) {
+            $totalHours += $dailyHours[$date] ?? 0;
+        }
+
+        return $totalHours;
+    }
+
+    /**
+     * Check if WorkContractBundle plugin is installed and available
+     * 
+     * @return bool True if bundle is available
+     */
+    private function isWorkContractBundleAvailable(): bool
+    {
+        return $this->publicHolidayRepository !== null &&
+            class_exists('KimaiPlugin\WorkContractBundle\WorkContractBundle');
+    }
+}
\ No newline at end of file