chill-bundles/src/Bundle/ChillDocGeneratorBundle/Controller/DocGeneratorTemplateController.php

<?php

/**
 * Chill is a software for social workers
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

declare(strict_types=1);

/**
 * Chill is a software for social workers.
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace Chill\DocGeneratorBundle\Controller;

use ChampsLibres\AsyncUploaderBundle\TempUrl\TempUrlGeneratorInterface;
use Chill\DocGeneratorBundle\Context\HouseholdMemberSelectionContext;
use Chill\DocGeneratorBundle\Entity\DocGeneratorTemplate;
use Chill\DocGeneratorBundle\Repository\DocGeneratorTemplateRepository;
use Chill\DocStoreBundle\Entity\StoredObject;
use Chill\PersonBundle\Entity\AccompanyingPeriod\AccompanyingPeriodWorkEvaluation;
use Chill\PersonBundle\Entity\AccompanyingPeriod\AccompanyingPeriodWorkEvaluationDocument;
use Chill\PersonBundle\Entity\SocialWork\Evaluation;
use Exception;
use GuzzleHttp\Client;
use GuzzleHttp\Exception\TransferException;
use PhpOffice\PhpWord\TemplateProcessor;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;

// TODO à mettre dans services
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class DocGeneratorTemplateController extends AbstractController
{
    /**
     * @Route(
     *     "{_locale}/doc/gen/generate/from/{template}/for/{entityClassName}/{entityId}",
     *     name="chill_docgenerator_generate_from_template"
     * )
     */
    public function generateDocFromTemplateAction(
        TempUrlGeneratorInterface $tempUrlGenerator,
        DocGeneratorTemplate $template,
        string $entityClassName,
        int $entityId,
        Request $request
    ): Response {
        $getUrlGen = $tempUrlGenerator->generate(
            'GET',
            $template->getFile()
        );

        $tmpfname = tempnam(sys_get_temp_dir(), 'DOC_TEMPLATE');
        file_put_contents($tmpfname, file_get_contents($getUrlGen->url));

        $entity = $this->getDoctrine()->getRepository($entityClassName)->find($entityId);

        if ($template->getContext() === HouseholdMemberSelectionContext::class) {
            $context = new HouseholdMemberSelectionContext();
            $datas = $context->getData($entity);
        } else {
            throw new Exception('Not implemented', 1);
        }

        $templateProcessor = new TemplateProcessor($tmpfname);

        foreach ($datas['setValues'] as $setValuesConf) {
            $templateProcessor->setValues($setValuesConf);
        }

        foreach ($datas['cloneRowAndSetValues'] as $cloneRowAndSetValues) {
            $templateProcessor->cloneRowAndSetValues($cloneRowAndSetValues[0], $cloneRowAndSetValues[1]);
        }

        $tmpfname2 = tempnam(sys_get_temp_dir(), 'DOC_GENERATED');
        $templateProcessor->saveAs($tmpfname2);

        unlink($tmpfname);

        $fileContent = fopen($tmpfname2, 'rb'); // the generated file content

        $genDocName = 'doc_' . sprintf('%010d', mt_rand()) . '.docx';

        $getUrlGen = $tempUrlGenerator->generate(
            'PUT',
            $genDocName
        );

        unlink($tmpfname2);

        $client = new Client();

        try {
            $putResponse = $client->request('PUT', $getUrlGen->url, [
                'body' => $fileContent,
            ]);

            if ($putResponse->getStatusCode() === 201) {
                $em = $this->getDoctrine()->getManager();
                $storedObject = new StoredObject();
                $storedObject
                    // currently, only docx is supported
                    ->setType('application/vnd.openxmlformats-officedocument.wordprocessingml.document')
                    ->setFilename($genDocName);

                $em->persist($storedObject);

                // Only for evaluation
                if ($entity instanceof AccompanyingPeriodWorkEvaluation) {
                    $doc = new AccompanyingPeriodWorkEvaluationDocument();
                    $doc
                        ->setStoredObject($storedObject)
                        ->setTemplate($template);
                    $entity->addDocument($doc);
                    $em->persist($doc);
                }

                $em->flush();

                return $this->redirectToRoute('chill_wopi_file_edit', [
                    'fileId' => $storedObject->getUuid(),
                    'returnPath' => $request->query->get('returnPath', '/'),
                ]);
            }
        } catch (TransferException $e) {
            throw $e;
        }

        throw new Exception('Unable to generate document.');
    }

    /**
     * @Route(
     *     "{_locale}/doc/gen/templates/for/{entityClassName}",
     *     name="chill_docgenerator_templates_for_entity_api"
     * )
     */
    public function listTemplateApiAction(
        string $entityClassName,
        DocGeneratorTemplateRepository $templateRepository
    ): Response {
        $entities = $templateRepository->findByEntity($entityClassName);

        $ret = [];

        foreach ($entities as $entity) {
            $ret[] = [
                'id' => $entity->getId(),
                'name' => $entity->getName(),
                'description' => $entity->getDescription(),
            ];
        }

        return new JsonResponse(['results' => $ret]);
    }
}