src/Application/Internit/SolicitacaoBundle/Controller/SolicitacaoAdminController.php line 966

Open in your IDE?
  1. <?php
  3. namespace App\Application\Internit\SolicitacaoBundle\Controller;
  5. use App\Application\Internit\AgendamentoBundle\Entity\Agendamento;
  6. use App\Application\Internit\AndamentoSolicitacaoBundle\Entity\AndamentoSolicitacao;
  7. use App\Application\Internit\EmpreendimentoBundle\Entity\Empreendimento;
  8. use App\Application\Internit\OrdemServicoBundle\Entity\OrdemServico;
  9. use App\Application\Internit\PeriodoAgendamentoBundle\Entity\PeriodoAgendamento;
  10. use App\Application\Internit\PesquisaSatisfacaoBundle\Entity\PesquisaSatisfacao;
  11. use App\Application\Internit\PesquisaSatisfacaoBundle\Entity\Resposta;
  12. use App\Application\Internit\ProfissionalBundle\Entity\Profissional;
  13. use App\Application\Internit\RespostaSolicitacaoBundle\Entity\RespostaSolicitacao;
  14. use App\Application\Internit\SolicitacaoBundle\Entity\Solicitacao;
  15. use App\Application\Internit\SolicitacaoBundle\Form\SolicitacaoAdminType;
  16. use App\Application\Internit\StatusSolicitacaoBundle\Entity\StatusSolicitacao;
  17. use App\Application\Project\ContentBundle\Attributes\Acl as ACL;
  19. use App\Application\Project\ContentBundle\Controller\Base\BaseAdminController;
  20. use App\Application\Project\ContentBundle\Service\FilterDoctrine;
  21. use Doctrine\Persistence\ObjectRepository;
  22. use Sonata\AdminBundle\Bridge\Exporter\AdminExporter;
  23. use Sonata\AdminBundle\Datagrid\ProxyQueryInterface;
  24. use Symfony\Component\HttpFoundation\JsonResponse;
  25. use Symfony\Component\HttpFoundation\Request;
  26. use Symfony\Component\HttpFoundation\Response;
  27. use function Symfony\Component\String\s;
  29. #[ACL\Admin(enable: true, title: 'Solicitacao', description: 'Permissões modulo Solicitacao')]
  30. class SolicitacaoAdminController extends BaseAdminController
  31. {
  32.     protected $baseRoute = 'admin_internit_solicitacao_solicitacao_';
  33.     protected $baseTemplate = "@ApplicationInternitSolicitacao/solicitacao/";
  35.     public function dashboardAction()
  36.     {
  37.         return new JsonResponse([]);
  39.         /* Here goes your code */
  40.     }
  42.     public function getClass(): string
  43.     {
  44.         return Solicitacao::class;
  45.     }
  47.     public function getRepository(): ObjectRepository
  48.     {
  49.         return $this->managerRegistry->getManager()->getRepository($this->getClass());
  50.     }
  52.     /*#[ACL\Admin(enable: true, title: 'Listar', description: 'Listar Solicitacao')]
  53.     public function listAction(Request $request): Response
  54.     {
  55.         $this->validateAccess("listAction");
  57.         return parent::listAction($request);
  58.     }*/
  60.     #[ACL\Admin(enable: true, title: 'Listar', description: 'Listar Solicitacao')]
  61.     public function listAction(Request $request): Response
  62.     {
  63.         $this->assertObjectExists($request);
  65.         $this->admin->checkAccess('list');
  67.         $preResponse = $this->preList($request);
  68.         if (null !== $preResponse) {
  69.             return $preResponse;
  70.         }
  72.         $listMode = $request->get('_list_mode');
  73.         if (\is_string($listMode)) {
  74.             $this->admin->setListMode($listMode);
  75.         }
  77.         $datagrid = $this->admin->getDatagrid();
  78.         $formView = $datagrid->getForm()->createView();
  80.         // set the theme for the current Admin Form
  81.         $this->setFormTheme($formView, $this->admin->getFilterTheme());
  83.         //$template = $this->templateRegistry->getTemplate('list');
  85.         if ($this->container->has('sonata.admin.admin_exporter')) {
  86.             $exporter = $this->container->get('sonata.admin.admin_exporter');
  87.             \assert($exporter instanceof AdminExporter);
  88.             $exportFormats = $exporter->getAvailableFormats($this->admin);
  89.         }
  91.         $solicitacoes = $this->managerRegistry->getManager()->getRepository(Solicitacao::class)->findAll();
  92.         $jsonSolicitacoes = [];
  93.         foreach ($solicitacoes as $solicitacao) {
  94.             $jsonSolicitacoes[] = [
  95.                 'id' => $solicitacao->getId(),
  96.                 'codigo' => $solicitacao->getCodigo(),
  97.                 'nomeCliente' => (!empty($solicitacao->getCliente()->getNomeCompleto()))? $solicitacao->getCliente()->getNomeCompleto() : $solicitacao->getCliente()->getNomeFantasia(),
  98.                 'mensagem' => $solicitacao->getMensagem(),
  99.                 'dataCriacao' => $this->formatDateTime($solicitacao->getCreatedAt()),
  100.             ];
  101.         }
  104.         return $this->renderWithExtraParams($this->baseTemplate.'admin/list.html.twig', [
  105.             'action' => 'list',
  106.             'form' => $formView,
  107.             'solicitacoes' => json_encode($jsonSolicitacoes),
  108.             'datagrid' => $datagrid,
  109.             'csrf_token' => $this->getCsrfToken('sonata.batch'),
  110.             'export_formats' => $exportFormats ?? $this->admin->getExportFormats(),
  111.         ]);
  112.     }
  114.     #[ACL\Admin(enable: true, title: 'Visualizar', description: 'Visualizar Solicitacao')]
  115.     public function showAction(Request $request): Response
  116.     {
  117.         $this->validateAccess("showAction");
  118.         //return parent::showAction($request);
  120.         $id = $request->get('id');
  121.         if(!$id)
  122.             return $this->redirectToRoute($this->baseRoute.'list');
  123.         return $this->redirectToRoute($this->baseRoute.'edit', ['id' => $id]);
  125.     }
  127.     #[ACL\Admin(enable: true, title: 'Criar', description: 'Criar Solicitacao')]
  128.     public function createAction(Request $request): Response
  129.     {
  130.         $this->validateAccess("createAction");
  132.         //return parent::createAction($request);
  133.         $entityManager = $this->managerRegistry->getManager();
  135.         $data = new Solicitacao();
  136.         $data->setUltimaInteracao('Atendimento');
  137.         $form = $this->createForm(SolicitacaoAdminType::class, $data);
  139.         //dd($etapas);
  141.         $form->handleRequest($request);
  143.         if($form->isSubmitted() && $form->isValid()){
  145.             /** @var Solicitacao $data */
  146.             $data = $form->getData();
  148.             $statusSolicitacao = $entityManager->getRepository(StatusSolicitacao::class)->findOneBy(['id' => 1]);
  149.             $data->setStatusAtual($statusSolicitacao);
  150.             $data->setUltimaInteracao('Atendimento');
  152.             /** Cria Galeria caso não exista */
  153.             $data->setAnexos($this->mediaService->createGallery());
  154.             /** Cria as Medias e retorna array */
  155.             $medias = $this->mediaService->createMultipleMedia($data->getMultipleUpload());
  156.             /** Adicionar medias em galeria */
  157.             $this->mediaService->addMediaInGallery($medias, $data->getAnexos());
  158.             /** Atualiza a galeria de Media conforme a request*/
  159.             $this->mediaService->mediaUpdateRequest($data->getAnexos(), $request);
  161.             $entityManager->persist($data);
  162.             $entityManager->flush();
  164.             if($data->getCliente()){
  165.                 $flagName = ($data->getCliente()->getNomeCompleto()) ?
  166.                     strtoupper(substr($data->getCliente()->getNomeCompleto(), 0, 3)) :
  167.                     strtoupper(substr($data->getCliente()->getCnpj(), 0, 3)) ;
  169.                 $data->setCodigo($flagName."000".$data->getCliente()->getId().".".$data->getId());
  170.                 $entityManager->persist($data);
  171.                 $entityManager->flush();
  172.             }
  174.             if($data->getResponsavelAtendimento())
  175.                 $this->notificarResponsavelAtendimento($data);
  177.             $this->getRepository()->primeiroAndamentoSolicitacao($data);
  178.             $this->notificarCliente($data);
  180.             $redirectAction = $request->get('btn_action');
  182.             if($redirectAction === "btn_create_and_edit")
  183.                 return $this->redirectToRoute($this->baseRoute . 'edit', ['id' => $data->getId()]);
  185.             if($redirectAction === "btn_create_and_list")
  186.                 return $this->redirectToRoute($this->baseRoute . 'list');
  188.             if($redirectAction === "btn_create_and_create")
  189.                 return $this->redirectToRoute($this->baseRoute . 'create');
  190.         }
  192.         $template = $this->baseTemplate . "admin/create.html.twig";
  193.         return $this->renderWithExtraParams($template,[
  194.             'title' => 'Criar',
  195.             'form' => $form->createView(),
  196.         ]);
  198.     }
  200.     #[ACL\Admin(enable: true, title: 'Editar', description: 'Editar Solicitacao')]
  201.     public function editAction(Request $request): Response
  202.     {
  203.         $this->validateAccess("editAction");
  205.         //return parent::editAction($request);
  207.         $entityManager = $this->managerRegistry->getManager();
  209.         /*** @var Solicitacao $existingObject */
  210.         $existingObject = $this->assertObjectExists($request, true);
  211.         $existingObject->setEmpreendimento($existingObject->getUnidade()->getBloco()->getEmpreendimento());
  212.         $existingObject->setBloco($existingObject->getUnidade()->getBloco());
  213.         $lastResponsavel = $existingObject->getResponsavelAtendimento();
  216.         if(!$existingObject)
  217.             return $this->redirectToRoute($this->baseRoute . 'list');
  219.         $form = $this->createForm(SolicitacaoAdminType::class, $existingObject);
  220.         $form->handleRequest($request);
  222.         if($form->isSubmitted()){
  224.             /** @var Solicitacao $data */
  225.             $data = $form->getData();
  226.             $data->setUltimaInteracao('Atendimento');
  228.             if( !$data->getAnexos() )
  229.                 $data->setAnexos($this->mediaService->createGallery());
  231.             /** Cria as Medias e retorna array */
  232.             $medias = $this->mediaService->createMultipleMedia($data->getMultipleUpload());
  234.             /** Adicionar medias em galeria */
  235.             $this->mediaService->addMediaInGallery($medias, $data->getAnexos());
  237.             /** Atualiza a galeria de Media conforme a request*/
  238.             $this->mediaService->mediaUpdateRequest($data->getAnexos(), $request);
  240.             $entityManager->persist($data);
  241.             $entityManager->flush();
  243.             if($data->getCliente()){
  244.                 $flagName = utf8_encode(($data->getCliente()->getNomeCompleto()) ?
  245.                     strtoupper(substr($data->getCliente()->getNomeCompleto(), 0, 3)) :
  246.                     strtoupper(substr($data->getCliente()->getCnpj(), 0, 3))) ;
  248.                 $data->setCodigo($flagName."000".$data->getCliente()->getId().".".$data->getId());
  249.                 $entityManager->persist($data);
  250.                 $entityManager->flush();
  251.             }
  253.             if($data->getResponsavelAtendimento())
  254.                 if(!$lastResponsavel || ($data->getResponsavelAtendimento()->getId() !== $lastResponsavel->getId()) )
  255.                     $this->notificarResponsavelAtendimento($data);
  257.             $this->notificarCliente($data);
  259.             $redirectAction = $request->get('btn_action');
  261.             if($redirectAction === "btn_create_and_edit")
  262.                 return $this->redirectToRoute($this->baseRoute . 'edit', ['id' => $data->getId()]);
  264.             if($redirectAction === "btn_create_and_list")
  265.                 return $this->redirectToRoute($this->baseRoute . 'list');
  267.         }
  269.        // dump($existingObject);
  271.         $ordemServicos = [];
  272.         foreach ($existingObject->getAndamentoSolicitacao() as $andamento) {
  273.             /*** @var AndamentoSolicitacao $andamento */
  274.             if($andamento->getAgendamento()){
  275.                 foreach ($andamento->getAgendamento()->getOrdemServicos() as $ordemServico)
  276.                 $ordemServicos[] = $ordemServico;
  277.             }
  278.         }
  280.         $pesquisa = $entityManager->getRepository(PesquisaSatisfacao::class)->findOneBy(['solicitacao' => $existingObject]);
  282.         $extraInfos = [
  283.             'statusSolicitacao' => $entityManager->getRepository(StatusSolicitacao::class)->findAll(),
  284.             'periodos' => $entityManager->getRepository(PeriodoAgendamento::class)->findAll(),
  285.             'profissionais' => $entityManager->getRepository(Profissional::class)->findAll(),
  286.             'andamentos' => $entityManager->getRepository(AndamentoSolicitacao::class)->findBy(['solicitacao' => $existingObject], ['createdAt' => 'DESC']),
  287.             'chat' => $this->getDataChat($existingObject->getId()),
  288.             'ordemServicos' => $ordemServicos,
  289.             'pesquisa' => (!$pesquisa)? null : [
  290.                 'pesquisa' => $pesquisa,
  291.                 'respostas' => $this->getRespostaPesquisa($pesquisa),
  292.             ],
  293.         ];
  295.         return $this->renderWithExtraParams($this->baseTemplate.'admin/edit.html.twig',[
  296.             'title' => 'Editar',
  297.             'form' => $form->createView(),
  298.             'object' => $existingObject,
  299.             'extraInfos' => $extraInfos,
  300.         ]);
  303.     }
  305.     private function getRespostaPesquisa(PesquisaSatisfacao $pesquisa)
  306.     {
  307.         $em = $this->managerRegistry->getManager();
  309.         $respostas = [
  310.             'atendente' => null,
  311.             'profissional' => []
  312.         ];
  314.         $solicitacao = $pesquisa->getSolicitacao();
  315.         $respostasData = $em->getRepository(Resposta::class)->findBy([
  316.             'pesquisaSatisfacao' => $pesquisa->getId()], [
  317.             'createdAt' => 'DESC'
  318.         ]);
  320.         if($solicitacao->getResponsavelAtendimento()){
  321.             $perguntas = [];
  322.             foreach ($respostasData as $resp) {
  323.                 if($resp->getResponsavelAtendimento()){
  324.                     $perguntas[] = [
  325.                         'pergunta' => $resp->getPergunta(),
  326.                         'resposta' => $resp->getResposta(),
  327.                         'tipoPergunta' => $resp->getTipoPergunta(),
  328.                     ];
  329.                 }
  330.             }
  331.             $respostas['atendente'] = [
  332.                 'id' => $solicitacao->getResponsavelAtendimento()->getId(),
  333.                 'nome' => $solicitacao->getResponsavelAtendimento()->getName(),
  334.                 'imagem' => $this->mediaService->getMediaJson($solicitacao->getResponsavelAtendimento()->getLogo()),
  335.                 'perguntas' => $perguntas,
  336.             ];
  337.         }
  339.         foreach ($solicitacao->getAllProffisionais() as $profissional) {
  340.             $perguntas = [];
  341.             foreach ($respostasData as $resp) {
  342.                 if($resp->getProfissional() && $resp->getProfissional()->getId() == $profissional->getId()){
  343.                     $perguntas[] = [
  344.                         'pergunta' => $resp->getPergunta(),
  345.                         'resposta' => $resp->getResposta(),
  346.                         'tipoPergunta' => $resp->getTipoPergunta(),
  347.                     ];
  348.                 }
  349.             }
  351.             $respostas['profissional'][] = [
  352.                 'id' => $profissional->getId(),
  353.                 'nome' => $profissional->getNomecompleto(),
  354.                 'imagem' => $this->mediaService->getMediaJson($profissional->getLogo()),
  355.                 'perguntas' => $perguntas,
  356.             ];
  357.         }
  359.         return $respostas;
  360.     }
  363.     #[ACL\Admin(enable: true, title: 'Excluir', description: 'Excluir Solicitacao')]
  364.     public function deleteAction(Request $request): Response
  365.     {
  366.         $this->validateAccess("deleteAction");
  368.         return parent::deleteAction($request);
  369.     }
  371.     #[ACL\Admin(enable: true, title: 'Excluir em Lote', description: 'Excluir Solicitacao em lote')]
  372.     public function batchActionDelete(ProxyQueryInterface $query): Response
  373.     {
  374.         $this->validateAccess("batchActionDelete");
  376.         return parent::batchActionDelete($query);
  377.     }
  379.     public function batchAction(Request $request): Response
  380.     {
  381.         $this->validateAccess("batchActionDelete");
  383.         return parent::batchAction($request);
  384.     }
  386.     #[ACL\Admin(enable: true, title: 'Exportar', description: 'Exportar Solicitacao')]
  387.     public function exportAction(Request $request): Response
  388.     {
  389.         $this->validateAccess("exportAction");
  391.         return parent::exportAction($request);
  392.     }
  394.     #[ACL\Admin(enable: true, title: 'Auditoria', description: 'Auditar Solicitacao')]
  395.     public function historyAction(Request $request): Response
  396.     {
  397.         $this->validateAccess("historyAction");
  399.         return parent::historyAction($request);
  400.     }
  402.     public function historyViewRevisionAction(Request $request, string $revision): Response
  403.     {
  404.         $this->validateAccess("historyAction");
  406.         return parent::historyViewRevisionAction($request, $revision);
  407.     }
  409.     public function historyCompareRevisionsAction(Request $request, string $baseRevision, string $compareRevision): Response
  410.     {
  411.         $this->validateAccess("historyAction");
  413.         return parent::historyCompareRevisionsAction($request, $baseRevision, $compareRevision);
  414.     }
  417.     /** ##############################
  418.      * API */
  420.     public function apiGetAndamentoSolicitacaoAction(Request $request): JsonResponse
  421.     {
  422.         $this->validateAccess("listAction");
  424.         $id = $request->get('id');
  426.         /** @var $andamentoSolicitacao AndamentoSolicitacao */
  427.         $andamentoSolicitacao = $this->managerRegistry->getRepository(AndamentoSolicitacao::class)->findOneBy(['id' => $id]);
  429.         $profissionais = [];
  430.         if($andamentoSolicitacao->getAgendamento())
  431.             foreach ($andamentoSolicitacao->getAgendamento()->getProfissionais() as $profissional){
  432.                 $profissionais[] = $profissional->getId();
  433.             }
  435.         $response = [
  436.             'id' => $andamentoSolicitacao->getId(),
  437.             'status' => ($andamentoSolicitacao->getStatusSolicitacao())? $andamentoSolicitacao->getStatusSolicitacao()->getId(): null,
  438.             'solicitacao' => $andamentoSolicitacao->getSolicitacao()->getId(),
  439.             'assunto' => $andamentoSolicitacao->getAssunto(),
  440.             'mensagem' => $andamentoSolicitacao->getMensagem(),
  441.             'visivel' => $andamentoSolicitacao->getVisivel(),
  442.             'agendamento' => !$andamentoSolicitacao->getAgendamento()? null : [
  443.                 'id' => $andamentoSolicitacao->getAgendamento()->getId(),
  444.                 'data' => date_format($andamentoSolicitacao->getAgendamento()->getData(), 'Y-m-d'),
  445.                 'periodo' => date_format($andamentoSolicitacao->getAgendamento()->getHora(), 'H:i'),
  446.                 'observacoes' => $andamentoSolicitacao->getAgendamento()->getObservacoes(),
  447.                 'profissionais' => $profissionais,
  448.                 'anexos' => $this->mediaService->getGalleryJson($andamentoSolicitacao->getAgendamento()->getAnexos()),
  449.             ],
  450.         ];
  452.         return $this->json($response);
  453.     }
  455.     public function listAndamentoSolicitacaoAction(Request $request): JsonResponse
  456.     {
  457.         $em = $this->managerRegistry->getManager();
  458.         $data = json_decode( $request->getContent() );
  459.         $solicitacao = $data->solicitacao;
  461.         $andamentos = $em->getRepository(AndamentoSolicitacao::class)->findBy(['solicitacao' => $solicitacao], ['createdAt' => 'DESC']);
  463.         $response = [];
  464.         /** @var $andamentoSolicitacao AndamentoSolicitacao */
  465.         foreach ($andamentos as $andamentoSolicitacao) {
  466.             $response[] = [
  467.                 'id' => $andamentoSolicitacao->getId(),
  468.                 'status' => ($andamentoSolicitacao->getStatusSolicitacao())? $andamentoSolicitacao->getStatusSolicitacao()->getStatus(): null,
  469.                 'solicitacao' => $andamentoSolicitacao->getSolicitacao()->getId(),
  470.                 'assunto' => $andamentoSolicitacao->getAssunto(),
  471.                 'mensagem' => $andamentoSolicitacao->getMensagem(),
  472.                 'visivel' => $andamentoSolicitacao->getVisivel(),
  473.                 'createdAt' => $andamentoSolicitacao->getCreatedAt()? date_format($andamentoSolicitacao->getCreatedAt(),"d/m/Y H:i:s"): null,
  474.                 'updatedAt' => $andamentoSolicitacao->getUpdatedAt()? date_format($andamentoSolicitacao->getUpdatedAt(),"d/m/Y H:i:s"): null,
  475.             ];
  476.         }
  478.         return $this->json($response);
  479.     }
  481.     public function novoAndamentoSolicitacaoAction(Request $request): JsonResponse
  482.     {
  483.         $em = $this->managerRegistry->getManager();
  484.         $data = (object) $request->request->all();
  486.         $status = $data->status;
  487.         $solicitacao = $data->solicitacao;
  488.         $mensagem = $data->mensagem;
  489.         $visivel = $data->visivel;
  490.         $agendamentoPeriodo = $data->agendamento['periodo'];
  491.         $agendamentoData = $data->agendamento['data'];
  492.         $agendamentoProfissionais = explode(',',$data->agendamento['profissionais'] );
  493.         $agendamentoObservacoes = $data->agendamento['observacoes'];
  495.         $anexos = [];
  496.         for ($i=0; $i<10; $i++) {
  497.             if (isset($request->files->get('agendamento')['file-' . $i]))
  498.             {
  499.                 $file = $request->files->get('agendamento')['file-'.$i];
  500.                 if($file)
  501.                     $anexos[] = $file;
  502.             }
  503.         }
  505. /*
  506.         var_dump($anexos);
  507.         return $this->json('');*/
  509.         $andamentoSolicitacao = new AndamentoSolicitacao();
  511.         $andamentoSolicitacao->setAlteradoPor($this->getUser());
  512.         $andamentoSolicitacao->setCriadoPor($this->getUser());
  513.         $andamentoSolicitacao->setVisivel($visivel);
  514.         $solicitacao = $em->getRepository(Solicitacao::class)->findOneBy(['id' => $solicitacao]);
  515.         if($solicitacao)
  516.             $andamentoSolicitacao->setSolicitacao($solicitacao);
  518.         $status = $em->getRepository(StatusSolicitacao::class)->findOneBy(['id' => $status]);
  519.         if($status)
  520.             $andamentoSolicitacao->setStatusSolicitacao($status);
  522.         if(in_array($status->getId(), [4,6])){
  523.             $agendamento = new Agendamento();
  525.             $agendamento->setData(new \DateTime($agendamentoData));
  526.             $agendamento->setHora(new \DateTime($agendamentoPeriodo));
  527.             $agendamento->setObservacoes($agendamentoObservacoes);
  528.             foreach ($agendamentoProfissionais as $profissional){
  529.                 $profissional = $em->getRepository(Profissional::class)->find($profissional);
  530.                 if($profissional)
  531.                     $agendamento->getProfissionais()->add($profissional);
  532.             }
  534.             if($anexos){
  535.                 $agendamento->setAnexos($this->mediaService->createGallery());
  536.                 $medias = $this->mediaService->createMultipleMedia($anexos);
  537.                 $this->mediaService->addMediaInGallery($medias, $agendamento->getAnexos());
  538.             }
  540.             $mensagem = str_replace(
  541.                 ['{data}', '{hora}'],
  542.                 [$this->formatDate($agendamento->getData()), date_format($agendamento->getHora(), 'H:i')],
  543.                 $mensagem
  544.             );
  546.             $em->persist($agendamento);
  547.             $em->flush();
  548.             $andamentoSolicitacao->setAgendamento($agendamento);
  549.             $andamentoSolicitacao->setMensagem($mensagem);
  551.             $em->persist($andamentoSolicitacao);
  552.             $em->flush();
  554.             $this->createOrdemServico($agendamento, $solicitacao, $andamentoSolicitacao);
  555.         } else {
  556.             $andamentoSolicitacao->setMensagem($mensagem);
  557.         }
  559.         $em->persist($andamentoSolicitacao);
  560.         $em->flush();
  562.         if($andamentoSolicitacao->getVisivel()){
  564.             $solicitacao = $andamentoSolicitacao->getSolicitacao();
  565.             $solicitacao->setStatusAtual($andamentoSolicitacao->getStatusSolicitacao());
  566.             $solicitacao->setUltimaInteracao('Atendimento');
  567.             $em->persist($solicitacao);
  568.             $em->flush();
  570.             $this->notificarCliente($andamentoSolicitacao->getSolicitacao());
  572.             if($status->getId() === 7){
  573.                 $this->createPesquisaSatisfacao($andamentoSolicitacao->getSolicitacao());
  574.             }
  576.         }
  578.         return $this->json(['status' => true]);
  579.     }
  581.     public function editAndamentoSolicitacaoAction(Request $request): JsonResponse
  582.     {
  583.         $em = $this->managerRegistry->getManager();
  584.         $data = json_decode( $request->getContent() );
  586.         $id = $data->id;
  587.         $status = $data->status;
  588.         $solicitacao = $data->solicitacao;
  589.         $mensagem = $data->mensagem;
  590.         $visivel = $data->visivel;
  592.         /** @var $andamentoSolicitacao AndamentoSolicitacao */
  593.         $andamentoSolicitacao = $em->getRepository(AndamentoSolicitacao::class)->findOneBy(['id' => $id]);
  594.         $status = $em->getRepository(StatusSolicitacao::class)->findOneBy(['id' => $status]);
  595.         if($status)
  596.             $andamentoSolicitacao->setStatusSolicitacao($status);
  598.         $andamentoSolicitacao->setMensagem($mensagem);
  599.         $andamentoSolicitacao->setVisivel($visivel);
  600.         $andamentoSolicitacao->setAlteradoPor($this->getUser());
  602.         if(in_array($status->getId(), [4,6])){
  603.             $agendamento = $andamentoSolicitacao->getAgendamento();
  604.             if(!$agendamento)
  605.                 $agendamento = new Agendamento();
  607.             $agendamento->setData(new \DateTime($data->agendamento->data));
  608.             $agendamento->setHora(new \DateTime($data->agendamento->periodo));
  609.             $agendamento->setObservacoes($data->agendamento->observacoes);
  610.             $agendamento->getProfissionais()->clear();
  611.             foreach ($data->agendamento->profissionais as $profissional){
  612.                 $profissional = $em->getRepository(Profissional::class)->find($profissional);
  613.                 if($profissional)
  614.                     $agendamento->getProfissionais()->add($profissional);
  615.             }
  616.             $em->persist($agendamento);
  617.             $em->flush();
  619.             $andamentoSolicitacao->setAgendamento($agendamento);
  621.             $em->persist($andamentoSolicitacao);
  622.             $em->flush();
  624.       /*      $resposta  = new RespostaSolicitacao();
  625.             $resposta->setMensagem('Sua vistoria foi agendada para o dia '.
  626.                 $this->formatDate($agendamento->getData()) . ' às '. $this->formatTime($agendamento->getHora())
  627.             );
  628.             $resposta->setRespondidoPor('atendimento');
  629.             $resposta->setAndamentoSolicitacao($andamentoSolicitacao);
  630.             $em->persist($resposta);
  631.             $em->flush();*/
  633.             //$this->createOrdemServico($agendamento);
  634.         }else{
  635.             if($andamentoSolicitacao->getAgendamento()){
  636.                 $em->remove($andamentoSolicitacao->getAgendamento());
  637.                 $em->flush();
  638.             }
  639.             $andamentoSolicitacao->setAgendamento(null);
  640.         }
  642.         $em->persist($andamentoSolicitacao);
  643.         $em->flush();
  645.         if($andamentoSolicitacao->getVisivel()){
  647.             $solicitacao = $andamentoSolicitacao->getSolicitacao();
  648.             $solicitacao->setStatusAtual($andamentoSolicitacao->getStatusSolicitacao());
  649.             $solicitacao->setUltimaInteracao('Atendimento');
  650.             $em->persist($solicitacao);
  651.             $em->flush();
  653.             $this->notificarCliente($andamentoSolicitacao->getSolicitacao());
  655.             if($status->getId() === 7){
  656.                 $this->createPesquisaSatisfacao($andamentoSolicitacao->getSolicitacao());
  657.             }
  659.         }
  663.         return $this->json(['status' => true]);
  664.     }
  666.     public function deleteAndamentoSolicitacaoAction(Request $request): JsonResponse
  667.     {
  668.         $em = $this->managerRegistry->getManager();
  670.         $data = json_decode( $request->getContent() );
  672.         $id = $data->id;
  673.         /** @var $andamento AndamentoSolicitacao */
  674.         $andamento = $em->getRepository(AndamentoSolicitacao::class)->findOneBy(['id' => $id]);
  675.         if(!$andamento)
  676.             return $this->json(['message' => 'Andamento não encontrado.'],400);
  678.         if($andamento->getAgendamento())
  679.             if(count($andamento->getAgendamento()->getOrdemServicos()->toArray()))
  680.                 return $this->json(['message' => 'Não é possível excluir o status atual pois ele possui uma ordem de serviço associada!'],400);
  682.         if($andamento->getAgendamento()){
  683.             $em->remove($andamento->getAgendamento());
  684.             $em->flush();
  685.         }
  687.         /** @var $solicitacao Solicitacao */
  688.         $solicitacao = $andamento->getSolicitacao();
  690.         $em->remove($andamento);
  691.         $em->flush();
  693.         /** @var $andamento AndamentoSolicitacao */
  694.         $andamento = $solicitacao->getAndamentoSolicitacao()->last();
  695.         $solicitacao->setStatusAtual(($andamento)? $andamento->getStatusSolicitacao() : null);
  696.         $em->persist($solicitacao);
  697.         $em->flush();
  699.         return $this->json([]);
  700.     }
  703.     /************************************************************************************************************
  704.      * Respostas
  705.      */
  707.     public function listRespostasSolicitacaoAction(Request $request): JsonResponse
  708.     {
  709.         $em = $this->managerRegistry->getManager();
  710.         $data = json_decode( $request->getContent() );
  711.         $andamento = $data->andamento;
  713.         $respostas = $em->getRepository(RespostaSolicitacao::class)->findBy(['andamentoSolicitacao' => $andamento], ['createdAt' => 'DESC']);
  715.         $response = [];
  716.         /** @var $resposta RespostaSolicitacao */
  717.         foreach ($respostas as $resposta) {
  718.             $response[] = [
  719.                 'id' => $resposta->getId(),
  720.                 'andamento' => $resposta->getAndamentoSolicitacao()->getId(),
  721.                 'assunto' => $resposta->getAssunto(),
  722.                 'mensagem' => $resposta->getMensagem(),
  723.                 'respondidoPor' => $resposta->getRespondidoPor(),
  724.                 'createdAt' => $resposta->getCreatedAt()? date_format($resposta->getCreatedAt(),"d/m/Y H:i:s"): null,
  725.                 'updatedAt' => $resposta->getUpdatedAt()? date_format($resposta->getUpdatedAt(),"d/m/Y H:i:s"): null,
  726.             ];
  727.         }
  729.         return $this->json($response);
  730.     }
  732.     public function getRespostaSolicitacaoAction(Request $request): JsonResponse
  733.     {
  734.         $this->validateAccess("listAction");
  736.         $id = $request->get('id');
  738.         /** @var $resposta RespostaSolicitacao */
  739.         $resposta = $this->managerRegistry->getRepository(RespostaSolicitacao::class)->findOneBy(['id' => $id]);
  741.         $response = [
  742.             'id' => $resposta->getId(),
  743.             'andamento' => $resposta->getAndamentoSolicitacao()->getId(),
  744.             'assunto' => $resposta->getAssunto(),
  745.             'mensagem' => $resposta->getMensagem(),
  746.             'respondidoPor' => $resposta->getRespondidoPor(),
  747.             'createdAt' => $resposta->getCreatedAt()? date_format($resposta->getCreatedAt(),"d/m/Y H:i:s"): null,
  748.             'updatedAt' => $resposta->getUpdatedAt()? date_format($resposta->getUpdatedAt(),"d/m/Y H:i:s"): null,
  749.         ];
  751.         return $this->json($response);
  752.     }
  754.     public function novaRespostaSolicitacaoAction(Request $request): JsonResponse
  755.     {
  756.         $em = $this->managerRegistry->getManager();
  759.         $solicitacao = $request->request->get('solicitacao');
  760.         $mensagem = $request->request->get('mensagem');
  762.         $anexos = [];
  763.         for ($i=0; $i<10; $i++){
  764.             $file = $request->files->get('file-'.$i);
  765.             if($file)
  766.                 $anexos[] = $file;
  767.         }
  769.         if(!$mensagem)
  770.             return $this->json(['message' => 'Mensagem não encontrado.'],400);
  772.         $solicitacao = $em->getRepository(Solicitacao::class)->find($solicitacao);
  773.         if(!$solicitacao)
  774.             return $this->json(['message' => 'Solicitação não encontrado.'],400);
  776.         $resposta = new RespostaSolicitacao();
  777.         $resposta->setAndamentoSolicitacao($solicitacao->getAndamentoSolicitacao()->last());
  778.         $resposta->setMensagem($mensagem);
  779.         $resposta->setRespondidoPor('atendimento');
  780.         $resposta->setAdminResposta($this->getUser());
  782.         if($anexos){
  783.             /** Cria Galeria caso não exista */
  784.             $resposta->setAnexos($this->mediaService->createGallery());
  785.             /** Cria as Medias e retorna array */
  786.             $medias = $this->mediaService->createMultipleMedia($anexos);
  787.             /** Adicionar medias em galeria */
  788.             $this->mediaService->addMediaInGallery($medias, $resposta->getAnexos());
  789.         }
  791.         $em->persist($resposta);
  792.         $em->flush();
  794.         if($resposta->getAndamentoSolicitacao()->getVisivel()){
  796.             $solicitacao = $resposta->getAndamentoSolicitacao()->getSolicitacao();
  797.             $solicitacao->setUltimaInteracao('Atendimento');
  798.             $em->persist($solicitacao);
  799.             $em->flush();
  801.             $this->notificarCliente($solicitacao);
  802.         }
  804.         return $this->json(['status' => true]);
  805.     }
  807.     public function editRespostaSolicitacaoAction(Request $request): JsonResponse
  808.     {
  809.         $em = $this->managerRegistry->getManager();
  810.         $data = json_decode( $request->getContent() );
  812.         $id = $data->id;
  813.         $andamento = $data->andamento;
  814.         $mensagem = $data->mensagem;
  816.         /** @var $resposta RespostaSolicitacao */
  817.         $resposta = $em->getRepository(RespostaSolicitacao::class)->findOneBy(['id' => $id]);
  819.         $resposta->setMensagem($mensagem);
  821.         $em->persist($resposta);
  822.         $em->flush();
  825.         if($resposta->getAndamentoSolicitacao()->getVisivel()){
  826.             $solicitacao = $resposta->getAndamentoSolicitacao()->getSolicitacao();
  827.             $solicitacao->setUltimaInteracao('Atendimento');
  828.             $em->persist($solicitacao);
  829.             $em->flush();
  831.             $this->notificarCliente($solicitacao);
  832.         }
  834.         return $this->json(['status' => true]);
  835.     }
  837.     public function deleteRespostaSolicitacaoAction(Request $request): JsonResponse
  838.     {
  839.         $em = $this->managerRegistry->getManager();
  841.         $data = json_decode( $request->getContent() );
  843.         $id = $data->id;
  844.         $resposta = $em->getRepository(RespostaSolicitacao::class)->findOneBy(['id' => $id]);
  845.         if(!$resposta)
  846.             return $this->json(['message' => 'Resposta não encontrado.'],400);
  848.         $em->remove($resposta);
  849.         $em->flush();
  851.         return $this->json([]);
  852.     }
  854.     /************************************************************************************************************
  855.      * Ordem de Serviço
  856.      */
  858.     public function apiListOrdemServicoAction(Request $request): JsonResponse
  859.     {
  860.         $em = $this->managerRegistry->getManager();
  861.         $data = json_decode( $request->getContent() );
  862.         $solicitacao = $data->solicitacao;
  864.         $andamentos = $em->getRepository(AndamentoSolicitacao::class)->findBy(['solicitacao' => $solicitacao], ['createdAt' => 'DESC']);
  866.         $response = [];
  867.         /** @var $andamentoSolicitacao AndamentoSolicitacao */
  868.         foreach ($andamentos as $andamentoSolicitacao) {
  869.             if(!$andamentoSolicitacao->getAgendamento())
  870.                 continue;
  872.             /** @var $ordemServico OrdemServico */
  873.             foreach ($andamentoSolicitacao->getAgendamento()->getOrdemServicos() as $ordemServico){
  874.                 $response[] = [
  875.                     'id' => $ordemServico->getId(),
  876.                     'codigo' => $ordemServico->getCodigo(),
  877.                     'profissional' => $ordemServico->getProfissional()->getNomecompleto(),
  878.                     'status' => $ordemServico->getStatus(),
  879.                     'dataAgendamento' => $this->formatDate($ordemServico->getData()),
  880.                     'horaAgendamento' => $this->formatTime($ordemServico->getHora()),
  881.                     'createdAt' => $this->formatDateTime($ordemServico->getCreatedAt()),
  882.                     'updatedAt' => $this->formatDateTime($ordemServico->getUpdatedAt()),
  883.                 ];
  884.             }
  885.         }
  887.         return $this->json($response);
  888.     }
  890.     public function apiGetOrdemServicoAction(Request $request): JsonResponse
  891.     {
  892.         $this->validateAccess("listAction");
  894.         $id = $request->get('id');
  896.         /** @var $andamentoSolicitacao AndamentoSolicitacao */
  897.         $ordemServico = $this->managerRegistry->getRepository(OrdemServico::class)->findOneBy(['id' => $id]);
  898.         if(!$ordemServico)
  899.             return $this->json(['status' => false, 'message' => 'Ordem de serviço não encontrada!']);
  901.         /** @var Solicitacao $solicitacao */
  902.         $solicitacao = $ordemServico->getAgendamento()->getAndamento()->getSolicitacao();
  904.         $response = [
  905.             'id' => $ordemServico->getId(),
  906.             'codigo' => $ordemServico->getCodigo(),
  907.             'status' => $ordemServico->getStatus(),
  908.             'dataAgendamento' => $this->formatDate($ordemServico->getData()),
  909.             'horaAgendamento' => $this->formatTime($ordemServico->getHora()),
  910.             'mensagemDinamica' => $ordemServico->getAgendamento()->getObservacoes(),
  911.             'cliente' => (!$solicitacao->getCliente())? null: [
  912.                 'id' => $solicitacao->getCliente()->getId(),
  913.                 'nome' => $solicitacao->getCliente()->getNomeCompleto(),
  914.                 'telefone' => $solicitacao->getCliente()->getTelefone(),
  915.                 'email' => $solicitacao->getCliente()->getEmail(),
  916.             ],
  917.             'unidade' => (!$solicitacao->getUnidade())? null: [
  918.                 'empreendimento' => $solicitacao->getUnidade()->getBloco()->getEmpreendimento()->getNome(),
  919.                 'bloco' => $solicitacao->getUnidade()->getBloco()->getBloco(),
  920.                 'unidade' => $solicitacao->getUnidade()->getUnidade(),
  921.             ],
  922.             'agendamento' => (!$ordemServico->getAgendamento())? null: [
  923.                 'id'=> $ordemServico->getAgendamento()->getId()
  924.             ],
  925.             'profissional' => (!$ordemServico->getProfissional())? null: [
  926.                 'id'=> $ordemServico->getProfissional()->getId(),
  927.                 'nomeCompleto'=> $ordemServico->getProfissional()->getNomecompleto(),
  928.                 'email'=> $ordemServico->getProfissional()->getEmail(),
  929.             ],
  930.             'descricao' => $ordemServico->getDescricao(),
  931.             'anexosPreparacao' => $this->mediaService->getGalleryJson($ordemServico->getAnexosPreparacao()),
  932.             'anexosTrabalhoAndamento' => $this->mediaService->getGalleryJson($ordemServico->getAnexosTrabalhoAndamento()),
  933.             'anexosTrabalhoFinalizado' => $this->mediaService->getGalleryJson($ordemServico->getAnexosTrabalhoFinalizado()),
  934.             'assinaturaCliente' => $this->mediaService->getMediaJson($ordemServico->getAssinaturaCliente()),
  935.             'assinaturaProfissional' => $this->mediaService->getMediaJson($ordemServico->getAssinaturaProfissional()),
  936.             'aCaminho' => $this->formatDateTime($ordemServico->getDataACaminho()),
  937.             'inicioAtendimento' => $this->formatDateTime($ordemServico->getDataIniciarAtendimento()),
  938.             'finalAtendimento' => $this->formatDateTime($ordemServico->getDataFinalAtendimento()),
  939.             'criadoEm' => $this->formatDateTime($ordemServico->getCreatedAt()),
  940.             'atualizadoEm' => $this->formatDateTime($ordemServico->getUpdatedAt()),
  941.         ];
  943.         return $this->json($response);
  944.     }
  946.     public function deleteOrdemServicoAction(Request $request): JsonResponse
  947.     {
  948.         $em = $this->managerRegistry->getManager();
  950.         $id = $request->get('id');
  951.         $ordemServico = $em->getRepository(OrdemServico::class)->findOneBy(['id' => $id]);
  952.         if(!$ordemServico)
  953.             return $this->json(['message' => 'Ordem de serviço não encontrado.'],400);
  955.         $em->remove($ordemServico);
  956.         $em->flush();
  958.         return $this->json([]);
  959.     }
  962.     /************************************************************************************************************
  963.      * Chat
  964.      */
  966.     public function chatAction(Request $request): JsonResponse
  967.     {
  968.         $em = $this->managerRegistry->getManager();
  970.         $solicitacao = $request->get('solicitacao');
  972.         $response = $this->getDataChat($solicitacao);
  974.         return new JsonResponse($response);
  975.     }
  977.     public function getDataChat($solicitacaoId)
  978.     {
  979.         $em = $this->managerRegistry->getManager();
  981.         $andamentos = $em->getRepository(AndamentoSolicitacao::class)->findBy(['solicitacao' => $solicitacaoId], ['createdAt' => 'ASC']);
  983.         $response = [];
  984.         /** @var $andamento AndamentoSolicitacao */
  985.         foreach ($andamentos as $andamento) {
  987.             $respostasData = $em->getRepository(RespostaSolicitacao::class)->findBy(['andamentoSolicitacao' => $andamento->getId()], ['createdAt' => 'ASC']);
  989.             $respostas = [];
  990.             /** @var $resposta RespostaSolicitacao */
  991.             foreach ($respostasData as $resposta) {
  992.                 $respostas[] = [
  993.                     'id' => $resposta->getId(),
  994.                     'assunto' => $resposta->getAssunto(),
  995.                     'mensagem' => $resposta->getMensagem(),
  996.                     'respondidoPor' => $resposta->getRespondidoPor(),
  997.                     'criadoEm' => $this->formatDateTime($resposta->getCreatedAt()) ,
  998.                     'atualizadoEm' => $this->formatDateTime($resposta->getUpdatedAt()),
  999.                     'anexos' => $this->mediaService->getGalleryJson($resposta->getAnexos()),
  1000.                 ];
  1001.             }
  1003.             $profissionais = [];
  1004.             if($andamento->getAgendamento())
  1005.                 foreach ($andamento->getAgendamento()->getProfissionais() as $profissional){
  1006.                     $profissionais[] = $profissional->getId();
  1007.                 }
  1009.             $response[] = [
  1010.                 'id' => $andamento->getId(),
  1011.                 'status' => !$andamento->getStatusSolicitacao()? null: [
  1012.                     'id' => $andamento->getStatusSolicitacao()->getId(),
  1013.                     'status' => $andamento->getStatusSolicitacao()->getStatus(),
  1014.                 ],
  1015.                 'assunto' => $andamento->getAssunto(),
  1016.                 'mensagem' => $andamento->getMensagem(),
  1017.                 'visivel' =>  $andamento->getVisivel(),
  1018.                 'criadoEm' =>  $this->formatDateTime($andamento->getCreatedAt()),
  1019.                 'atualizadoEm' => $this->formatDateTime($andamento->getUpdatedAt()) ,
  1020.                 'agendamento' => !$andamento->getAgendamento()? null : [
  1021.                     'id' => $andamento->getAgendamento()->getId(),
  1022.                     'data' => date_format($andamento->getAgendamento()->getData(), 'Y-m-d'),
  1023.                     'periodo' => date_format($andamento->getAgendamento()->getData(), 'h:i'),
  1024.                     'observacoes' => $andamento->getAgendamento()->getObservacoes(),
  1025.                     'profissionais' => $profissionais,
  1026.                 ],
  1027.                 'respostas' => $respostas,
  1028.             ];
  1029.         }
  1031.         return $response;
  1032.     }
  1036.     /************************************************************************************************************
  1037.      * Aux
  1038.      */
  1040.     public function createPesquisaSatisfacao(Solicitacao $solicitacao)
  1041.     {
  1042.         $pesquisa = new PesquisaSatisfacao();
  1043.         $pesquisa->setSolicitacao($solicitacao);
  1044.         $pesquisa->setCliente($solicitacao->getCliente());
  1046.         $this->managerRegistry->getManager()->persist($pesquisa);
  1047.         $this->managerRegistry->getManager()->flush();
  1049.         $mail = $this->serviceEmail->getEmail();
  1050.         $mail->addAddress($solicitacao->getCliente()->getEmail());
  1051.         $mail->Subject = 'Aguardando Avaliação';
  1053.         $mail->Body = $this->renderTemplateEmail('emails/solicitacao/notificacao_cliente_pesquisa_satisfacao.html.twig', [
  1054.             'solicitacao' => $solicitacao,
  1055.         ]);
  1057.         $mail->send();
  1058.     }
  1060.     public function notificarCliente(Solicitacao $solicitacao): void
  1061.     {
  1062.         $mail = $this->serviceEmail->getEmail();
  1063.         $mail->addAddress($solicitacao->getCliente()->getEmail());
  1064.         $mail->Subject = 'Atualização de Solicitação';
  1066.         $mail->Body = $this->renderTemplateEmail('emails/solicitacao/notificacao_cliente_atualizacao_solicitacao.html.twig', [
  1067.             'solicitacao' => $solicitacao,
  1068.         ]);
  1070.         $mail->send();
  1071.     }
  1073.     public function notificarResponsavelAtendimento(Solicitacao $solicitacao): void
  1074.     {
  1075.         /*$mail = $this->serviceEmail->getEmail();
  1076.         $mail->addAddress($solicitacao->getResponsavelAtendimento()->getEmail());
  1077.         $mail->Subject = 'Atribuição de Solicitação';
  1079.         $mail->Body = $this->renderTemplateEmail('emails/solicitacao/agendamento/notificacao_reponsavelAtendimento.html.twig', [
  1080.             'solicitacao' => $solicitacao,
  1081.         ]);
  1083.         $mail->send();*/
  1084.     }
  1087.     public function createOrdemServico(Agendamento $agendamento, Solicitacao $solicitacao, AndamentoSolicitacao $andamento): void
  1088.     {
  1089.         $em = $this->managerRegistry->getManager();
  1091.         $empresa = $this->serviceEmail->getEmpresa();
  1093.         /** @var $profissional Profissional */
  1094.         foreach ($agendamento->getProfissionais() as $profissional) {
  1096.             $ordemServico = new OrdemServico();
  1097.             $ordemServico->setAgendamento($agendamento);
  1098.             $ordemServico->setData($agendamento->getData());
  1099.             $ordemServico->setHora($agendamento->getHora());
  1100.             $ordemServico->setProfissional($profissional);
  1101.             $ordemServico->setStatus('Agendado');
  1102.             $em->persist($ordemServico);
  1103.             $em->flush();
  1104.             $ordemServico->setCodigo("DIN00" . $ordemServico->getId() . "-1");
  1105.             $em->persist($ordemServico);
  1106.             $em->flush();
  1108.             $urlProfissional = ( (substr($empresa->getUrlCliente(), -1) == '/')? $empresa->getUrlCliente(): $empresa->getUrlCliente().'/')
  1109.                 .'os/'.$profissional->getId().'/'.str_replace(' ', '-', $profissional->getNomecompleto());
  1111.             /** START Fluxo SMS */
  1112.             $phone = ($profissional->getTelefone1())?: $profissional->getTelefone2();
  1113.             $nomeProfissional = explode(' ', $profissional->getNomecompleto());
  1114.                         
  1115.             $message = "Olá ". $nomeProfissional[0] .", a OS ". $ordemServico->getCodigo() .
  1116.                 " está disponível para a execução, acesse: ".
  1117.                 $urlProfissional . " Att, " . $empresa->getNome();
  1118.             
  1119.             if($phone)
  1120.                 $this->serviceComteleSMS->sendSMS($phone,$message);
  1121.             /** END Fluxo SMS */
  1123.             /** START Fluxo Email */
  1124.             $mail = $this->serviceEmail->getEmail();
  1125.             $mail->addAddress($profissional->getEmail());
  1126.             if($solicitacao->getResponsavelAtendimento())
  1127.                 $mail->addReplyTo($solicitacao->getResponsavelAtendimento()->getEmail());
  1128.             $mail->Subject = 'Nova Ordem de Serviço';
  1129.             $mail->Body = $this->renderTemplateEmail('emails/solicitacao/agendamento/notificacao_profissional_os_criada.html.twig', [
  1130.                 'profissional' => $profissional,
  1131.                 'os' => $ordemServico,
  1132.                 'urlProfissional' => $urlProfissional,
  1133.             ]);
  1134.             $mail->send();
  1135.             /** END Fluxo Email */
  1137.         }
  1140.     }
  1143.     public function apiDashboardSolicitacoesAction(Request $request)
  1144.     {
  1145.         $em = $this->managerRegistry->getManager();
  1147.         $empreendimentosFilter = ($request->query->get('empreendimentos'))? explode(",", $request->query->get('empreendimentos')): false;
  1148.         $dataAgendamentoDe = ($request->query->get('dataAgendamentoDe'))? new \DateTime($request->query->get('dataAgendamentoDe')): false;
  1149.         $dataAgendamentoAte = ($request->query->get('dataAgendamentoAte'))? new \DateTime($request->query->get('dataAgendamentoAte')): false;
  1152.         $solicitacoes = $em->getRepository(Solicitacao::class)->findBy(['statusAtual' => 4]);
  1154.         $solicitacoesAgendadas = [];
  1155.         /** @var $solicitacao Solicitacao */
  1156.         foreach ($solicitacoes as $solicitacao) {
  1158.             $andamento = $solicitacao->getAndamentoSolicitacao()->last();
  1159.             /** @var $agendamento Agendamento */
  1160.             $agendamento = $andamento->getAgendamento();
  1161.             if(!$agendamento)
  1162.                 continue;
  1164.             $profissionais = "";
  1165.             foreach ($agendamento->getProfissionais() as $profissional) {
  1166.                 $profissionais .= $profissional->getNomecompleto() . ', ';
  1167.             }
  1169.             $dateNow = new \DateTime('now');
  1171.             /*if($agendamento->getData() < $dateNow)
  1172.                 continue;*/
  1174.             if($empreendimentosFilter && !in_array($solicitacao->getUnidade()->getBloco()->getEmpreendimento()->getId(), $empreendimentosFilter))
  1175.                 continue;
  1177.             if($dataAgendamentoDe && ($dataAgendamentoDe > $agendamento->getData()))
  1178.                 continue;
  1180.             if($dataAgendamentoAte && ($dataAgendamentoAte < $agendamento->getData()))
  1181.                 continue;
  1183.             $solicitacoesAgendadas[] = [
  1184.                 'id' => $solicitacao->getId(),
  1185.                 'codigo' => $solicitacao->getCodigo(),
  1186.                 'empreendimento'=> $solicitacao->getUnidade()->getBloco()->getEmpreendimento()->getNome(),
  1187.                 'bloco' => $solicitacao->getUnidade()->getBloco()->getBloco(),
  1188.                 'unidade' => $solicitacao->getUnidade()->getUnidade(),
  1189.                 'cliente' => $solicitacao->getCliente()->getNomeCompleto(),
  1190.                 'profissional' => $profissionais,
  1191.                 'dataAgendamento' => date_format($agendamento->getData(), 'd/m/Y') . ' ' .date_format($agendamento->getHora(), 'H:i'),
  1192.                 'mensagem' => $solicitacao->getMensagem(),
  1193.             ];
  1194.         }
  1196.         $empreendimentos = [];
  1197.         foreach ($em->getRepository(Empreendimento::class)->findBy([], ['nome' => 'ASC']) as $empreendimento) {
  1198.             $empreendimentos[] = [
  1199.                 'id' => $empreendimento->getId(),
  1200.                 'name' => $empreendimento->getNome(),
  1201.             ];
  1202.         }
  1204.         return $this->json([
  1205.            'solicitacoesAgendadas' => $solicitacoesAgendadas,
  1206.             'empreendimentos' => $empreendimentos,
  1207.         ]);
  1208.     }
  1214. }