Chamilo\CoreBundle\Serializer\UserToJsonNormalizer::getPersonalDataToJson()

Complexity

Conditions

39

Size

Total Lines	618
Code Lines	371

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function getPersonalDataToJson(int $userId, array $substitutionTerms): string
    {
        $em = $this->em;
        $dateFormat = DateTimeInterface::ATOM;

        /** @var User $user */
        $user = $this->userRepository->find($userId);

        $user->setPassword($substitutionTerms['password'] ?? '');
        $user->setSalt($substitutionTerms['salt'] ?? '');

        $noDataLabel = $substitutionTerms['empty'] ?? '';

        // Dummy content
        $user->setDateOfBirth(null);
        $user->setLocale($noDataLabel);
        $user->setTimezone($noDataLabel);
        $user->setWebsite($noDataLabel);

        // GradebookCertificate
        $result = $em->getRepository(GradebookCertificate::class)->findBy([
            'user' => $userId,
        ]);
        $gradebookCertificate = [];

        /** @var GradebookCertificate $item */
        foreach ($result as $item) {
            $createdAt = $item->getCreatedAt()->format($dateFormat);
            $list = [
                'Score: '.$item->getScoreCertificate(),
                'Path: '.$item->getPathCertificate(),
                'Created at: '.$createdAt,
            ];
            $gradebookCertificate[] = implode(', ', $list);
        }

        // TrackEExercises
        $result = $em->getRepository(TrackEExercise::class)->findBy([
            'user' => $userId,
        ]);
        $trackEExercises = [];

        /** @var TrackEExercise $item */
        foreach ($result as $item) {
            $date = $item->getExeDate()->format($dateFormat);
            $list = [
                'IP: '.$item->getUserIp(),
                'Start: '.$date,
                'Status: '.$item->getStatus(),
            ];
            $trackEExercises[] = implode(', ', $list);
        }

        // TrackEAttempt
        $result = $em->getRepository(TrackEAttempt::class)->findBy([
            'user' => $userId,
        ]);
        $trackEAttempt = [];

        /** @var TrackEAttempt $item */
        foreach ($result as $item) {
            $date = $item->getTms()->format($dateFormat);
            $list = [
                'Attempt #'.$item->getTrackEExercise()->getExeId(),
                // 'Answer: '.$item->getAnswer(),
                // 'Marks: '.$item->getMarks(),
                'Position: '.$item->getPosition(),
                'Date: '.$date,
            ];
            $trackEAttempt[] = implode(', ', $list);
        }

        // TrackECourseAccess
        $result = $em->getRepository(TrackECourseAccess::class)->findBy([
            'user' => $userId,
        ]);
        $trackECourseAccessList = [];

        /** @var TrackECourseAccess $item */
        foreach ($result as $item) {
            $startDate = $item->getLoginCourseDate()->format($dateFormat);
            $endDate = null !== $item->getLogoutCourseDate() ? $item->getLogoutCourseDate()->format($dateFormat) : '';
            $list = [
                'IP: '.$item->getUserIp(),
                'Start: '.$startDate,
                'End: '.$endDate,
            ];
            $trackECourseAccessList[] = implode(', ', $list);
        }

        $checkEntities = [
            TrackELogin::class => 'user',
            TrackEAccess::class => 'accessUserId',
            TrackEOnline::class => 'loginUserId',
            TrackEDefault::class => 'defaultUserId',
            TrackELastaccess::class => 'accessUserId',
            TrackEUploads::class => 'uploadUserId',
            GradebookResult::class => 'user',
            TrackEDownloads::class => 'downUserId',
        ];

        $maxResults = 1000;
        $trackResults = [];
        foreach ($checkEntities as $entity => $field) {
            $qb = $em->createQueryBuilder();
            $qb->select($qb->expr()->count('l'))
                ->from($entity, 'l')
                ->where("l.$field = :login")
                ->setParameter('login', $userId)
            ;
            $query = $qb->getQuery();
            $count = $query->getSingleScalarResult();

            if ($count > $maxResults) {
                $qb = $em->getRepository($entity)->createQueryBuilder('l');
                $qb
                    ->select('l')
                    ->where("l.$field = :login")
                    ->setParameter('login', $userId)
                ;
                $qb
                    ->setFirstResult(0)
                    ->setMaxResults($maxResults)
                ;
                $result = $qb->getQuery()->getResult();
            } else {
                $criteria = [
                    $field => $userId,
                ];
                $result = $em->getRepository($entity)->findBy($criteria);
            }
            $trackResults[$entity] = $result;
        }

        $trackELoginList = [];

        /** @var TrackELogin $item */
        foreach ($trackResults[TrackELogin::class] as $item) {
            $startDate = $item->getLoginDate()->format($dateFormat);
            $endDate = null !== $item->getLogoutDate() ? $item->getLogoutDate()->format($dateFormat) : '';
            $list = [
                'IP: '.$item->getUserIp(),
                'Start: '.$startDate,
                'End: '.$endDate,
            ];
            $trackELoginList[] = implode(', ', $list);
        }

        // TrackEAccess
        $trackEAccessList = [];

        /** @var TrackEAccess $item */
        foreach ($trackResults[TrackEAccess::class] as $item) {
            $date = $item->getAccessDate()->format($dateFormat);
            $list = [
                'IP: '.$item->getUserIp(),
                'Tool: '.$item->getAccessTool(),
                'End: '.$date,
            ];
            $trackEAccessList[] = implode(', ', $list);
        }

        // TrackEOnline
        $trackEOnlineList = [];

        /** @var TrackEOnline $item */
        foreach ($trackResults[TrackEOnline::class] as $item) {
            $date = $item->getLoginDate()->format($dateFormat);
            $list = [
                'IP: '.$item->getUserIp(),
                'Login date: '.$date,
                'Course # '.$item->getCId(),
                'Session # '.$item->getSessionId(),
            ];
            $trackEOnlineList[] = implode(', ', $list);
        }

        // TrackEDefault
        $trackEDefault = [];

        /** @var TrackEDefault $item */
        foreach ($trackResults[TrackEDefault::class] as $item) {
            $date = $item->getDefaultDate()->format($dateFormat);
            $list = [
                'Type: '.$item->getDefaultEventType(),
                'Value: '.$item->getDefaultValue(),
                'Value type: '.$item->getDefaultValueType(),
                'Date: '.$date,
                'Course #'.$item->getCId(),
                'Session # '.$item->getSessionId(),
            ];
            $trackEDefault[] = implode(', ', $list);
        }

        // TrackELastaccess
        $trackELastaccess = [];

        /** @var TrackELastaccess $item */
        foreach ($trackResults[TrackELastaccess::class] as $item) {
            $date = $item->getAccessDate()->format($dateFormat);
            $list = [
                'Course #'.$item->getCId(),
                'Session # '.$item->getSessionId(),
                'Tool: '.$item->getAccessTool(),
                'Access date: '.$date,
            ];
            $trackELastaccess[] = implode(', ', $list);
        }

        // TrackEUploads
        $trackEUploads = [];

        /** @var TrackEUploads $item */
        foreach ($trackResults[TrackEUploads::class] as $item) {
            $date = $item->getUploadDate()->format($dateFormat);
            $list = [
                'Course #'.$item->getCId(),
                'Uploaded at: '.$date,
                'Upload id # '.$item->getUploadId(),
            ];
            $trackEUploads[] = implode(', ', $list);
        }

        $gradebookResult = [];

        /** @var GradebookResult $item */
        foreach ($trackResults[GradebookResult::class] as $item) {
            $date = $item->getCreatedAt()->format($dateFormat);
            $list = [
                'Evaluation id# '.$item->getEvaluation()->getId(),
                // 'Score: '.$item->getScore(),
                'Creation date: '.$date,
            ];
            $gradebookResult[] = implode(', ', $list);
        }

        $trackEDownloads = [];

        /** @var TrackEDownloads $item */
        foreach ($trackResults[TrackEDownloads::class] as $item) {
            $date = $item->getDownDate()->format($dateFormat);
            $list = [
                'File: '.$item->getDownDocPath(),
                'Download at: '.$date,
            ];
            $trackEDownloads[] = implode(', ', $list);
        }

        // UserCourseCategory
        $result = $em->getRepository(UserCourseCategory::class)->findBy([
            'user' => $userId,
        ]);
        $userCourseCategory = [];

        /** @var UserCourseCategory $item */
        foreach ($result as $item) {
            $list = [
                'Title: '.$item->getTitle(),
            ];
            $userCourseCategory[] = implode(', ', $list);
        }

        // Forum
        $result = $em->getRepository(CForumPost::class)->findBy([
            'user' => $userId,
        ]);
        $cForumPostList = [];

        /** @var CForumPost $item */
        foreach ($result as $item) {
            $date = $item->getPostDate()->format($dateFormat);
            $list = [
                'Title: '.$item->getTitle(),
                'Creation date: '.$date,
            ];
            $cForumPostList[] = implode(', ', $list);
        }

        // CForumThread
        $result = $em->getRepository(CForumThread::class)->findBy([
            'user' => $userId,
        ]);
        $cForumThreadList = [];

        /** @var CForumThread $item */
        foreach ($result as $item) {
            $date = $item->getThreadDate()->format($dateFormat);
            $list = [
                'Title: '.$item->getTitle(),
                'Creation date: '.$date,
            ];
            $cForumThreadList[] = implode(', ', $list);
        }

        // cGroupRelUser
        $result = $em->getRepository(CGroupRelUser::class)->findBy([
            'user' => $userId,
        ]);
        $cGroupRelUser = [];

        /** @var CGroupRelUser $item */
        foreach ($result as $item) {
            $list = [
                'Course # '.$item->getCId(),
                'Group #'.$item->getGroup()->getIid(),
                'Role: '.$item->getStatus(),
            ];
            $cGroupRelUser[] = implode(', ', $list);
        }

        // CAttendanceSheet
        $result = $em->getRepository(CAttendanceSheet::class)->findBy([
            'user' => $userId,
        ]);
        $cAttendanceSheetList = [];

        /** @var CAttendanceSheet $item */
        foreach ($result as $item) {
            $list = [
                'Presence: '.$item->getPresence(),
                'Calendar id: '.$item->getAttendanceCalendar()->getIid(),
            ];
            $cAttendanceSheetList[] = implode(', ', $list);
        }

        // CAttendanceResult
        $result = $em->getRepository(CAttendanceResult::class)->findBy([
            'user' => $userId,
        ]);
        $cAttendanceResult = [];

        /** @var CAttendanceResult $item */
        foreach ($result as $item) {
            $list = [
                'Score : '.$item->getScore(),
                'Calendar id: '.$item->getAttendance()->getIid(),
            ];
            $cAttendanceResult[] = implode(', ', $list);
        }

        // Message
        $result = $em->getRepository(Message::class)->findBy([
            'sender' => $userId,
        ]);
        $messageList = [];

        /** @var Message $item */
        foreach ($result as $item) {
            $date = $item->getSendDate()->format($dateFormat);
            $userName = '';
            if ($item->getReceivers()) {
                foreach ($item->getReceivers() as $receiver) {
                    $userName = ', '.$receiver->getReceiver()->getUsername();
                }
            }

            $list = [
                'Title: '.$item->getTitle(),
                'Sent date: '.$date,
                'To users: '.$userName,
                'Type: '.$item->getMsgType(),
            ];
            $messageList[] = implode(', ', $list);
        }

        // CSurveyAnswer
        $result = $em->getRepository(CSurveyAnswer::class)->findBy([
            'user' => $userId,
        ]);
        $cSurveyAnswer = [];

        /** @var CSurveyAnswer $item */
        foreach ($result as $item) {
            $list = [
                'Answer # '.$item->getIid(),
                'Value: '.$item->getValue(),
            ];
            $cSurveyAnswer[] = implode(', ', $list);
        }

        // CDropboxFile
        $result = $em->getRepository(CDropboxFile::class)->findBy([
            'uploaderId' => $userId,
        ]);
        $cDropboxFile = [];

        /** @var CDropboxFile $item */
        foreach ($result as $item) {
            $date = $item->getUploadDate()->format($dateFormat);
            $list = [
                'Title: '.$item->getTitle(),
                'Uploaded date: '.$date,
                'File: '.$item->getFilename(),
            ];
            $cDropboxFile[] = implode(', ', $list);
        }

        // CDropboxPerson
        $result = $em->getRepository(CDropboxPerson::class)->findBy([
            'userId' => $userId,
        ]);
        $cDropboxPerson = [];

        /** @var CDropboxPerson $item */
        foreach ($result as $item) {
            $list = [
                'File #'.$item->getFileId(),
                'Course #'.$item->getCId(),
            ];
            $cDropboxPerson[] = implode(', ', $list);
        }

        // CDropboxPerson
        $result = $em->getRepository(CDropboxFeedback::class)->findBy([
            'authorUserId' => $userId,
        ]);
        $cDropboxFeedback = [];

        /** @var CDropboxFeedback $item */
        foreach ($result as $item) {
            $date = $item->getFeedbackDate()->format($dateFormat);
            $list = [
                'File #'.$item->getFileId(),
                'Feedback: '.$item->getFeedback(),
                'Date: '.$date,
            ];
            $cDropboxFeedback[] = implode(', ', $list);
        }

        // CNotebook
        $result = $em->getRepository(CNotebook::class)->findBy([
            'user' => $userId,
        ]);
        $cNotebook = [];

        /** @var CNotebook $item */
        foreach ($result as $item) {
            $date = $item->getUpdateDate()->format($dateFormat);
            $list = [
                'Title: '.$item->getTitle(),
                'Date: '.$date,
            ];
            $cNotebook[] = implode(', ', $list);
        }

        // CLpView
        $result = $em->getRepository(CLpView::class)->findBy([
            'user' => $userId,
        ]);
        $cLpView = [];

        /** @var CLpView $item */
        foreach ($result as $item) {
            $list = [
                // 'Id #'.$item->getId(),
                'LP #'.$item->getLp()->getIid(),
                'Progress: '.$item->getProgress(),
                // 'Course #'.$item->getCId(),
                // 'Session #'.$item->getSessionId(),
            ];
            $cLpView[] = implode(', ', $list);
        }

        // CStudentPublication
        $result = $em->getRepository(CStudentPublication::class)->findBy([
            'user' => $userId,
        ]);
        $cStudentPublication = [];

        /** @var CStudentPublication $item */
        foreach ($result as $item) {
            $list = [
                'Title: '.$item->getTitle(),
                // 'URL: '.$item->getTitle(),
            ];
            $cStudentPublication[] = implode(', ', $list);
        }

        // CStudentPublicationComment
        $result = $em->getRepository(CStudentPublicationComment::class)->findBy([
            'user' => $userId,
        ]);
        $cStudentPublicationComment = [];

        /** @var CStudentPublicationComment $item */
        foreach ($result as $item) {
            $date = $item->getSentAt()->format($dateFormat);
            $list = [
                'Commment: '.$item->getComment(),
                'File '.$item->getFile(),
                // 'Course # '.$item->getCId(),
                'Date: '.$date,
            ];
            $cStudentPublicationComment[] = implode(', ', $list);
        }

        // CWiki
        $result = $em->getRepository(CWiki::class)->findBy([
            'userId' => $userId,
        ]);
        $cWiki = [];

        /** @var CWiki $item */
        foreach ($result as $item) {
            $list = [
                'Title: '.$item->getTitle(),
                'Progress: '.$item->getProgress(),
                'IP: '.$item->getUserIp(),
            ];
            $cWiki[] = implode(', ', $list);
        }

        // Ticket
        $result = $em->getRepository(Ticket::class)->findBy([
            'insertUserId' => $userId,
        ]);
        $ticket = [];

        /** @var Ticket $item */
        foreach ($result as $item) {
            $list = [
                'Code: '.$item->getCode(),
                'Subject: '.$item->getSubject(),
            ];
            $ticket[] = implode(', ', $list);
        }

        // Message
        $result = $em->getRepository(TicketMessage::class)->findBy([
            'insertUserId' => $userId,
        ]);
        $ticketMessage = [];

        /** @var TicketMessage $item */
        foreach ($result as $item) {
            $date = $item->getInsertDateTime()->format($dateFormat);
            $list = [
                'Subject: '.$item->getSubject(),
                'IP: '.$item->getIpAddress(),
                'Status: '.$item->getStatus(),
                'Creation date: '.$date,
            ];
            $ticketMessage[] = implode(', ', $list);
        }

        // SkillRelUserComment
        $result = $em->getRepository(SkillRelUserComment::class)->findBy([
            'feedbackGiver' => $userId,
        ]);
        $skillRelUserComment = [];

        /** @var SkillRelUserComment $item */
        foreach ($result as $item) {
            $date = $item->getFeedbackDateTime()->format($dateFormat);
            $list = [
                'Feedback: '.$item->getFeedbackText(),
                'Value: '.$item->getFeedbackValue(),
                'Created at: '.$date,
            ];
            $skillRelUserComment[] = implode(', ', $list);
        }

        // UserRelCourseVote
        $result = $em->getRepository(UserRelCourseVote::class)->findBy([
            'user' => $userId,
        ]);
        $userRelCourseVote = [];

        /** @var UserRelCourseVote $item */
        foreach ($result as $item) {
            $list = [
                'Course #'.$item->getCourse()->getId(),
                // 'Session #'.$item->getSession()->getId(),
                'Vote: '.$item->getVote(),
            ];
            $userRelCourseVote[] = implode(', ', $list);
        }

        $lastLogin = $user->getLastLogin();
        $user->setLastLogin($lastLogin);

        $ignore = [
            'twoStepVerificationCode',
            'biography',
            'dateOfBirth',
            'gender',
            'facebookData',
            'facebookName',
            'facebookUid',
            'gplusData',
            'gplusName',
            'gplusUid',
            'locale',
            'timezone',
            'twitterData',
            'twitterName',
            'twitterUid',
            'gplusUid',
            'token',
            'website',
            'plainPassword',
            'completeNameWithUsername',
            'completeName',
            'completeNameWithClasses',
            'salt',
            'dropBoxSentFiles',
            'dropBoxReceivedFiles',
            'currentUrl',
            'uuid',
            'curriculumItems',
            'currentSession',
            'currentCourse',
            'resourceNode',
        ];

        return $this->serializer->serialize($user, 'json', [
            AbstractNormalizer::IGNORED_ATTRIBUTES => $ignore,
            'groups' => ['user_export'],
        ]);