Symfony Profiler

<?php
namespace App\EventSubscriber\Doctrine;
use App\Enum\ActivityLogCategoryEnum;
use App\Enum\ActivityLogMethodEnum;
use App\Enum\DocumentStatusEnum;
use App\Enum\DocumentTypeEnum;
use App\Enum\DocumentTypeOrganizationEnum;
use App\Enum\DocumentTypeUserEnum;
use App\Enum\OrganizationStatusEnum;
use App\Enum\SignatoryEnum;
use App\Service\DocumentFilesService;
use App\Service\DocumentUtils;
use App\Service\LegalRepresentativeUtils;
use App\Service\OrganizationUtils;
use App\Service\PersonUtils;
use App\Service\SegmentAPI;
use App\Service\SubscriptionUtils;
use App\Traits\SentryNotifyTrait;
use Doctrine\Common\EventSubscriber;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Event\PreUpdateEventArgs;
use Doctrine\Persistence\Event\LifecycleEventArgs;
use Evo\Domain\Core\SignatureServiceInterface;
use Evo\Domain\PappersActivityLogWrapper\Service\PappersActivityLogWrapperService;
use Evo\Infrastructure\MappingORM\ActivityLog;
use Evo\Infrastructure\MappingORM\Document;
use Evo\Infrastructure\MappingORM\LegalRepresentative;
use Evo\Infrastructure\MappingORM\Organization;
use Evo\Infrastructure\MappingORM\ProcessYousign;
use Evo\Infrastructure\MappingORM\Signature;
use Evo\Infrastructure\MappingORM\User;
use Evo\Infrastructure\PdfGenerator\PathGenerator;
use Evo\Infrastructure\PdfGenerator\PdfGenerator;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\HttpKernel\KernelInterface;
use Symfony\Component\Mercure\HubInterface;
use Symfony\Component\Mercure\Update;
use Symfony\Component\Security\Core\Authentication\Token\SwitchUserToken;
use Symfony\Component\Security\Core\Security;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Contracts\Translation\TranslatorInterface;
class DocumentSubscriber implements EventSubscriber
{
use SentryNotifyTrait;
public const CHANGE_STATUS_KEY = 'CHANGEMENT DE STATUT';
public const LEGAL_REPRESENTATIVE_KEY = 'REPRÉSENTANT LÉGAL';
public const SERVICE_NAME = '[DOCUMENT SUBSCRIBER] :: ';
public const CREATION_KEY = 'CREATION DOCUMENT';
public const GENERATED_DOCUMENTS = [
DocumentTypeEnum::DNC1,
DocumentTypeEnum::DNC2,
DocumentTypeEnum::HQ_OWNER,
DocumentTypeEnum::KOAH_POWER_OF_ATTORNEY,
DocumentTypeEnum::SUBSCRIBERS_LIST,
DocumentTypeEnum::DOMICILIATION_CONTRACT,
DocumentTypeEnum::DOMICILIATION_CERTIFICATE,
DocumentTypeEnum::NOTICE_OF_TERMINATION,
];
private OrganizationUtils $organizationUtils;
private ?string $filePath = null;
private ?string $relativePath = null;
private DocumentUtils $documentUtils;
private KernelInterface $kernel;
private SignatureServiceInterface $yousignAPI;
private PersonUtils $personUtils;
private SessionInterface $session;
private SegmentAPI $segmentAPI;
private EntityManagerInterface $em;
private ParameterBagInterface $params;
private TranslatorInterface $translator;
private Security $security;
private LegalRepresentativeUtils $legalRepresentativeUtils;
private RequestStack $requestStack;
private HubInterface $hub;
private DocumentFilesService $documentFilesService;
private PdfGenerator $pdfGenerator;
private PappersActivityLogWrapperService $pappersActivityLogWrapperService;
public function __construct(
OrganizationUtils $organizationUtils,
DocumentUtils $documentUtils,
PersonUtils $personUtils,
SignatureServiceInterface $yousignAPI,
SessionInterface $session,
KernelInterface $appKernel,
SegmentAPI $segmentAPI,
EntityManagerInterface $em,
TranslatorInterface $translator,
ParameterBagInterface $params,
LegalRepresentativeUtils $legalRepresentativeUtils,
Security $security,
RequestStack $requestStack,
HubInterface $hub,
PdfGenerator $documentGenerator,
PappersActivityLogWrapperService $pappersActivityLogWrapperService,
DocumentFilesService $documentFilesService
) {
$this->yousignAPI = $yousignAPI;
$this->translator = $translator;
$this->params = $params;
$this->session = $session;
$this->organizationUtils = $organizationUtils;
$this->documentUtils = $documentUtils;
$this->personUtils = $personUtils;
$this->kernel = $appKernel;
$this->em = $em;
$this->segmentAPI = $segmentAPI;
$this->security = $security;
$this->legalRepresentativeUtils = $legalRepresentativeUtils;
$this->requestStack = $requestStack;
$this->hub = $hub;
$this->pdfGenerator = $documentGenerator;
$this->pappersActivityLogWrapperService = $pappersActivityLogWrapperService;
$this->documentFilesService = $documentFilesService;
}
public function getSubscribedEvents(): array
{
return [
'prePersist',
'postPersist',
'postUpdate',
'preUpdate',
'postRemove',
];
}
public function postRemove(LifecycleEventArgs $args): void
{
/** @var Document $entity */
$entity = $args->getObject();
if (!$entity instanceof Document) {
return;
}
$this->updateStatusDomicialitionForOrganizations($entity);
}
public function preUpdate(PreUpdateEventArgs $args): void
{
$entity = $args->getObject();
if (!$entity instanceof Document) {
return;
}
if ($entity->isBypassSubscriber()) {
return;
}
$changeset = $args->getEntityChangeSet();
if ((1 === count($changeset) && (isset($changeset['status'])))
|| (isset($changeset['status'], $changeset['expirationDate']) && 2 === count($changeset))
) {
return;
}
if (isset($changeset['yousignLink']) || isset($changeset['path']) || isset($changeset['awsPath'])) {
return;
}
$this->initName($entity, isset($changeset['type']));
if (DocumentStatusEnum::UNDER_VALIDATION === $entity->getStatus() && DocumentTypeOrganizationEnum::POSTAL_POWER_OF_ATTORNEY === $entity->getType()) {
$entity->setAwaitingValidationDate(new \DateTime());
$this->segmentAPI->trackDocumentUnderValidation($entity);
}
}
public function postUpdate(LifecycleEventArgs $args): void
{
$impersonatorUser = null;
/** @var Document $entity */
$entity = $args->getObject();
if (!$entity instanceof Document) {
return;
}
if ($entity->isBypassSubscriber()) {
return;
}
try {
$this->sendPushMercureForContratBoth($entity);
} catch (\Exception $e) {
$this->captureSentryException($e);
}
$request = $this->requestStack->getCurrentRequest();
$uow = $args->getObjectManager()->getUnitOfWork();
$uow->computeChangeSets();
$changeset = $uow->getEntityChangeSet($entity);
$organization = $entity->getOrganization();
$person = $entity->getPerson();
if (isset($changeset['status'])) {
if (DocumentStatusEnum::NOT_APPROVED === $changeset['status'][1]) {
$params = [];
if (DocumentTypeOrganizationEnum::RIB === $entity->getType() && ($organization || $person)) {
$params = SubscriptionUtils::getSubscriptionDataToSegment($organization);
}
$precisionReason = null;
if ($request instanceof Request && $request->request) {
$precisionReason = $request->request->get('precision_reason');
$data = json_decode($request->getContent(), true);
$precisionReason = $data['precision_reason'] ?? $precisionReason;
}
$this->segmentAPI->trackRejectedDocument($entity, $params, $precisionReason);
} elseif (DocumentStatusEnum::APPROVED === $changeset['status'][1]) {
// reset message rejection if document is approved
$document = $entity->resetDocumentRejectionMessage();
try {
$this->em->persist($document);
if (
in_array($entity->getType(), [DocumentTypeEnum::STATUS, DocumentTypeEnum::KBIS, DocumentTypeEnum::DBE])
&& $document->isDocumentOfOrganization()
) {
$this->pappersActivityLogWrapperService->updateStatusToProcessed($organization);
}
$this->em->flush();
} catch (\Exception $e) {
$this->captureSentryException($e);
}
if (DocumentTypeOrganizationEnum::DOMICILIATION_CONTRACT !== $entity->getType() && ($organization || $person)) {
if (DocumentTypeOrganizationEnum::RIB === $entity->getType()) {
$params = SubscriptionUtils::getSubscriptionDataToSegment($organization);
} else {
$params = [];
}
$this->segmentAPI->trackApprovedDocument($entity, $params);
}
}
}
if (isset($changeset['type'])) {
$this->createActivityLogForTypeHasChanged($entity, $changeset, $impersonatorUser, $request);
}
$this->updateStatusDomicialitionForOrganizations($entity);
if (DocumentTypeEnum::OTHER !== $entity->getType()
|| $this->documentUtils->isHavingSimilarDocuments($entity->getOrganization(), $entity)) {
$this->documentUtils->removeSimilarDocuments($entity, DocumentTypeEnum::OTHER === $entity->getType());
}
if (isset($changeset['status'])) {
$changeset = $this->createActivityLogForStatusChanged($entity, $changeset, $impersonatorUser, $request);
}
if (1 === (is_countable($changeset) ? count($changeset) : 0) && isset($changeset['status']) && DocumentStatusEnum::APPROVED === $changeset['status'][1]) {
$this->organizationUtils->generateOnlyDomiciliationCertificate($entity);
return;
}
if (1 === (is_countable($changeset) ? count($changeset) : 0) && (isset($changeset['status']))) {
return;
}
/* return if yousignLink | yousignError | path | awsPath is updated */
if (isset($changeset['yousignLink']) || isset($changeset['yousignError']) || isset($changeset['path']) || isset($changeset['awsPath'])) {
return;
}
$this->signatureRequestYousign($entity);
/*
* Génération documents à l'exception { changement de la propriété "path" }
*/
$changeset = $this->generateDocsIfNecessary($changeset, $entity);
if (isset($changeset['signedBy'])) {
if (SignatoryEnum::BOTH === $changeset['signedBy'][1]) {
$this->segmentAPI->trackApprovedDocument($entity);
}
$this->createActivityLogForSignedByChanged($entity, $changeset, $impersonatorUser, $request);
}
}
private function updateStatusDomicialitionForOrganizations(Document $document): void
{
if (null !== $document->getPerson()) {
/** @var LegalRepresentative $legalRepresentative */
foreach ($document->getPerson()->getLegalRepresentatives() as $legalRepresentative) {
$organizations = $legalRepresentative->getOrganizations();
/** @var Organization $organization */
foreach ($organizations as $organization) {
$status = $this->organizationUtils->checkStatusDomiciliation($organization);
if ($status && $status !== $organization->getStatus()) {
$organization->setStatus($status);
$this->em->persist($organization);
$this->em->flush();
}
}
}
} elseif (null !== $document->getOrganization()) {
/** @var Organization $organization */
$organization = $document->getOrganization();
$status = $this->organizationUtils->checkStatusDomiciliation($organization);
if ($status && $status !== $organization->getStatus()) {
$organization->setStatus($status);
$this->em->persist($organization);
$this->em->flush();
}
}
}
public function prePersist(LifecycleEventArgs $args): void
{
$entity = $args->getObject();
if (!$entity instanceof Document) {
return;
}
if ($entity->isBypassSubscriber()) {
return;
}
$request = $this->requestStack->getCurrentRequest();
$arrayDocument = null !== $request ? $request->request->all() : [];
$mustGeneratedByPappers = $arrayDocument
&& $entity->isDocumentOfOrganization()
&& isset($arrayDocument['isPappersAbleToGenerate'])
&& 'true' === $arrayDocument['isPappersAbleToGenerate'];
$this->initName($entity);
if (DocumentTypeOrganizationEnum::DOMICILIATION_CONTRACT === $entity->getType()) {
$entity->setStatus(DocumentStatusEnum::APPROVED);
}
if (null !== $entity->getDocumentFile() || DocumentTypeOrganizationEnum::DOMICILIATION_CONTRACT_LARAVEL === $entity->getType()) {
return;
}
if (!$mustGeneratedByPappers && $entity->isDocumentOfOrganization()) {
$this->pdfGenerator->generate($entity);
}
$entity->setIsFromPappers($entity->getIsFromPappers() || $entity->isTemporaryFileForPappers());
if ($mustGeneratedByPappers) {
$isGenerated = $this->organizationUtils->generateDocsFromPappers($entity->getOrganization(), $entity);
if ($isGenerated) {
$entity->setIsFromPappers(true);
}
}
}
public function postPersist(LifecycleEventArgs $args): void
{
$entity = $args->getObject();
if (!$entity instanceof Document) {
return;
}
if ($entity->isBypassSubscriber()) {
return;
}
$this->updateStatusDomicialitionForOrganizations($entity);
if (null === $entity->getPerson() && null === $entity->getOrganization()) {
$this->sendSentryMessage(self::SERVICE_NAME.'Document Orphelin [postPersist] #'.$entity->getId(), 'debug');
} else {
if (DocumentTypeEnum::OTHER !== $entity->getType()
|| $this->documentUtils->isHavingSimilarDocuments($entity->getOrganization(), $entity)) {
$this->documentUtils->removeSimilarDocuments($entity, DocumentTypeEnum::OTHER === $entity->getType());
}
if ($entity->getId()) {
$this->signatureRequestYousign($entity);
}
}
if (DocumentStatusEnum::APPROVED === $entity->getStatus() && DocumentTypeOrganizationEnum::RIB !== $entity->getType()) {
$this->segmentAPI->trackApprovedDocument($entity);
}
if (DocumentStatusEnum::TO_APPROVE === $entity->getStatus() && DocumentTypeOrganizationEnum::RIB !== $entity->getType()) {
$this->segmentAPI->trackNewDocument($entity);
}
if (DocumentStatusEnum::NOT_APPROVED === $entity->getStatus() && DocumentTypeOrganizationEnum::RIB !== $entity->getType()) {
$this->segmentAPI->trackRejectedDocument($entity);
}
if ($entity->getOrganization() && $this->organizationUtils->checkGenerateCertificateDomiciliation($entity->getOrganization())) {
$aDocs[] = DocumentTypeOrganizationEnum::DOMICILIATION_CERTIFICATE;
$this->organizationUtils->generateDocs($entity->getOrganization(), false, $aDocs);
}
// create activity log for non generated file only
if (null === $entity->getOrganization() || !in_array($entity->getType(), self::GENERATED_DOCUMENTS, true)) {
$request = $this->requestStack->getCurrentRequest();
$token = $this->security->getToken();
if ($token instanceof SwitchUserToken) {
$impersonatorUser = $token->getOriginalToken()->getUser();
}
$user = $request instanceof Request ? $impersonatorUser ?? $this->security->getUser() : null;
$person = $entity->getPerson();
$legalRepresentative = $person ? $person->getLegalRepresentative() : null;
$activityLog = ActivityLog::create(
$user,
ActivityLogMethodEnum::CREATE,
self::CREATION_KEY,
ActivityLogCategoryEnum::DOCUMENTS,
[],
$entity->getOrganization(),
$legalRepresentative,
$this->translator->trans('enum.document.'.$entity->getType())
);
try {
$this->em->persist($activityLog);
$this->em->flush();
} catch (\Exception $e) {
$this->captureSentryException($e);
}
$activityWithStatus = ActivityLog::create(
$user,
ActivityLogMethodEnum::UPDATE,
'DOCUMENT '.$this->translator->trans(DocumentTypeEnum::getReadableValue($entity->getType())),
ActivityLogCategoryEnum::DOCUMENTS,
[
self::CHANGE_STATUS_KEY => [
'-' => $this->translator->trans(DocumentStatusEnum::getReadableValue($entity->getStatus())),
],
],
$entity->getOrganization(),
$legalRepresentative,
null
);
try {
$this->em->persist($activityWithStatus);
$this->em->flush();
} catch (\Exception $e) {
$this->captureSentryException($e);
}
}
}
private function signatureRequestYousign(Document $entity): void
{
if (DocumentTypeOrganizationEnum::DOMICILIATION_CONTRACT !== $entity->getType()) {
return;
}
if (!$this->documentFilesService->isFileExist(PathGenerator::generatePathForDocument($entity))) {
return;
}
if (!$entity->getOrganization()) {
return;
}
if ($entity->getOrganization()->getProcessYousign()) {
return;
}
/** @var Organization $organization */
$organization = $entity->getOrganization();
$user = $this->em->getRepository(User::class)->findOneBy(['email' => 'william@digidom.pro']);
$signers = [];
if ($user) {
switch ($entity->getOrganization()->getStatus()) {
case OrganizationStatusEnum::NEW_PAYMENT:
$status = 'validation-client';
break;
case OrganizationStatusEnum::DOCS_MISSING:
$status = 'non-urgent-client';
break;
default:
$status = 'autres';
break;
}
$redirectTo = getenv('URL_NEW_ADMIN').'/kyc/'.$status;
$signers[] = $this->yousignAPI->getSignerData($user, [
'success' => $redirectTo,
'error' => $redirectTo,
]);
}
$legalRepresentative = $this->legalRepresentativeUtils->getFirstPhysicalRepresentative($organization);
if ($legalRepresentative && in_array($entity->getOrganization()->getStatus(), [
OrganizationStatusEnum::NEW,
OrganizationStatusEnum::NEW_PAYMENT,
OrganizationStatusEnum::DOCS_MISSING,
OrganizationStatusEnum::DOCS_EXPIRED,
OrganizationStatusEnum::OK,
], true)) {
$signature = $this->em->getRepository(Signature::class)
->findOneBy(['legalRepresentative' => $legalRepresentative]);
if (!$signature) {
$signature = new Signature();
$signature->setLegalRepresentative($legalRepresentative);
}
try {
$signer = null;
$signatureRequest = $this->yousignAPI->createProcedure(
'Signature contrat de domiciliation #'.$organization->getId().' ('.$entity->getCreatedAt()->format('d-m-Y H:i:s').')',
PathGenerator::generatePathForDocument($entity),
$entity->getOrganization()->getId().'-'.$legalRepresentative->getId()
);
if ($this->yousignAPI->isResponseValid($signatureRequest)) {
try {
$this->yousignAPI->addMetadataToSignatureRequest($signatureRequest['id'], [
'organizationId' => $organization->getId(),
'legalRepresentativeId' => $legalRepresentative->getId(),
'documentType' => DocumentTypeOrganizationEnum::DOMICILIATION_CONTRACT,
]);
} catch (\Exception $e) {
// do nothing
}
$redirectToSuccess = $this->params->get('uri_tunnel').'/contrat/'.$organization->getId().'?signed=true';
$redirectToCancel = $this->params->get('uri_tunnel').'/contrat/'.$organization->getId().'?signed=false';
$signers[] = $this->yousignAPI->getSignerData($legalRepresentative, [
'success' => $redirectToSuccess,
'error' => $redirectToCancel,
]);
foreach ($signers as $signerData) {
$signer = $this->yousignAPI->addSigner($signatureRequest['id'], $signerData);
if (!$this->yousignAPI->isResponseValid($signer)) {
$this->sendSentryMessage(
self::SERVICE_NAME.' Signer: '.$signer.' #'.$organization->getId()
);
break;
}
}
}
if (is_string($signatureRequest)) {
$entity->setYousignError($signatureRequest);
}
if ($this->yousignAPI->isResponseValid($signatureRequest) && $this->yousignAPI->isResponseValid($signer)) {
$procedure = (new ProcessYousign())
->setSignatureRequestId($signatureRequest['id'])
->setExternalFileId($signatureRequest['documents'][0]['id'])
->setOrganization($organization)
->setLastUploadedFileAt(new \DateTime())
->addSignature($signature);
$this->em->persist($procedure);
$this->em->flush();
}
} catch (\Exception $e) {
$this->captureSentryException($e);
}
}
}
private function getReadableDocumentType(string $type): string
{
if (DocumentTypeUserEnum::isValueExist($type)) {
$trans = DocumentTypeUserEnum::getReadableValue($type);
} else {
$trans = DocumentTypeOrganizationEnum::getReadableValue($type);
}
return $trans;
}
private function initName(Document $entity, bool $typeHasChanged = false): void
{
if ($typeHasChanged || null === $entity->getName()) {
$type = $entity->getType();
$trans = $this->getReadableDocumentType($type);
$entity->setName($this->translator->trans($trans));
}
if (!$typeHasChanged) {
return;
}
$extension = explode('.', $entity->getPath());
$extension = end($extension);
try {
if ($entity->getPath()) {
$this->documentFilesService->copyFile(
$entity->getPath(),
PathGenerator::generatePathForDocument($entity, $extension, true)
);
}
} catch (\Exception $e) {
// do nothing
}
$entity->setPath(PathGenerator::generatePathForDocument($entity, $extension, true));
}
private function sendPushMercureForContratBoth(Document $entity): void
{
if (
DocumentTypeOrganizationEnum::DOMICILIATION_CONTRACT === $entity->getType()
&& null !== $entity->getOrganization()
&& SignatoryEnum::BOTH === $entity->getSignedBy()
) {
$update = new Update(
'http://api.digidom.pro/signal/kyc/finished',
json_encode([
'organizationId' => $entity->getOrganization()->getId(),
'status' => 'signed_by_both',
], JSON_THROW_ON_ERROR)
);
$this->hub->publish($update);
}
}
private function createActivityLog(Document $entity, array $changeset, string $changeType, ?UserInterface $impersonatorUser, ?Request $request, string $key = null): array
{
$token = $this->security->getToken();
if ($token instanceof SwitchUserToken) {
$impersonatorUser = $token->getOriginalToken()->getUser();
}
$user = $request instanceof Request ? $impersonatorUser ?? $this->security->getUser() : null;
$logs = [];
$changeLogTitle = 'DOCUMENT '.$this->translator->trans(DocumentTypeEnum::getReadableValue($entity->getType()));
switch ($changeType) {
case 'status':
$oldStatus = isset($changeset['status'][0]) ? $this->translator->trans(DocumentStatusEnum::getReadableValue($changeset['status'][0])) : '-';
$newStatus = $changeset['status'][1] ?? null;
$logs[$key ?? self::CHANGE_STATUS_KEY] = [
$oldStatus => $this->translator->trans(DocumentStatusEnum::getReadableValue($newStatus)),
];
break;
case 'type':
$logs[$key ?? 'CHANGEMENT DE TYPE'] = [
$this->translator->trans(DocumentTypeEnum::getReadableValue($changeset['type'][0])) => $this->translator->trans(DocumentTypeEnum::getReadableValue($entity->getType())),
];
break;
case 'signedBy':
$logs[$key ?? 'SIGNÉ PAR'] = [
(!empty($changeset['signedBy'][0])) ? $this->translator->trans(SignatoryEnum::getReadableValue($changeset['signedBy'][0])) : '-' => (!empty($changeset['signedBy'][1])) ? $this->translator->trans(SignatoryEnum::getReadableValue($entity->getSignedBy())) : '-',
];
}
if ($entity->isDocumentOfPerson()) {
$logs[self::LEGAL_REPRESENTATIVE_KEY] = [
'' => $entity->getPerson()->getFullName(),
];
}
$hasRejectedMessage = isset($newStatus) && DocumentStatusEnum::NOT_APPROVED === $newStatus && null !== $entity->getRejectionMessage();
$activityLog = ActivityLog::create(
$user,
ActivityLogMethodEnum::UPDATE,
$changeLogTitle,
ActivityLogCategoryEnum::DOCUMENTS,
$logs,
$entity->isDocumentOfOrganization() ? $entity->getOrganization() : null,
$entity->isDocumentOfPerson() ? $entity->getPerson()->getLegalRepresentative() : null,
$hasRejectedMessage ? $entity->getRejectionMessage()->getDescription() : null
);
try {
$this->em->persist($activityLog);
$this->em->flush();
} catch (\Exception $e) {
$this->captureSentryException($e);
}
return $changeset;
}
private function createActivityLogForSignedByChanged(Document $entity, array $changeset, ?UserInterface $impersonatorUser, ?Request $request = null): array
{
return $this->createActivityLog($entity, $changeset, 'signedBy', $impersonatorUser, $request);
}
private function createActivityLogForTypeHasChanged(Document $entity, array $changeset, ?UserInterface $impersonatorUser, ?Request $request = null): void
{
$this->createActivityLog($entity, $changeset, 'type', $impersonatorUser, $request);
}
private function createActivityLogForStatusChanged(Document $entity, array $changeset, ?UserInterface $impersonatorUser, ?Request $request = null): array
{
return $this->createActivityLog($entity, $changeset, 'status', $impersonatorUser, $request);
}
private function generateDocsIfNecessary($changeset, Document $entity)
{
if ((!empty($changeset) && !isset($changeset['path'])) && !$this->session->has('locked')) {
$this->session->set('locked', 1);
if (null !== $entity->getPerson()) {
$organizations = $this->personUtils->getOrganizations($entity->getPerson());
$organizationsOfLRParent = $this->personUtils->getOrganizationsParentOfLR($entity->getPerson());
$organizations = array_merge_recursive($organizations, $organizationsOfLRParent);
$organizationIDFinished = [];
/** @var Organization $organization */
foreach ($organizations as $organization) {
if (!in_array($organization->getId(), $organizationIDFinished)) {
$this->organizationUtils->generateDocs($organization, false);
$organizationIDFinished[] = $organization->getId();
}
}
} elseif (null !== $entity->getOrganization()) {
$this->organizationUtils->generateDocs($entity->getOrganization(), false);
}
}
return $changeset;
}
}

src/EventSubscriber/Doctrine/DocumentSubscriber.php line 715