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

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.         $andamentoSolicitacao->setMensagem($mensagem);
  515.         $solicitacao = $em->getRepository(Solicitacao::class)->findOneBy(['id' => $solicitacao]);
  516.         if($solicitacao)
  517.             $andamentoSolicitacao->setSolicitacao($solicitacao);
  519.         $status = $em->getRepository(StatusSolicitacao::class)->findOneBy(['id' => $status]);
  520.         if($status)
  521.             $andamentoSolicitacao->setStatusSolicitacao($status);
  523.         if(in_array($status->getId(), [4,6])){
  524.             $agendamento = new Agendamento();
  526.             $agendamento->setData(new \DateTime($agendamentoData));
  527.             $agendamento->setHora(new \DateTime($agendamentoPeriodo));
  528.             $agendamento->setObservacoes($agendamentoObservacoes);
  529.             foreach ($agendamentoProfissionais as $profissional){
  530.                 $profissional = $em->getRepository(Profissional::class)->find($profissional);
  531.                 if($profissional)
  532.                     $agendamento->getProfissionais()->add($profissional);
  533.             }
  535.             if($anexos){
  536.                 $agendamento->setAnexos($this->mediaService->createGallery());
  537.                 $medias = $this->mediaService->createMultipleMedia($anexos);
  538.                 $this->mediaService->addMediaInGallery($medias, $agendamento->getAnexos());
  539.             }
  541.             $em->persist($agendamento);
  542.             $em->flush();
  543.             $andamentoSolicitacao->setAgendamento($agendamento);
  545.             $em->persist($andamentoSolicitacao);
  546.             $em->flush();
  548.             $this->createOrdemServico($agendamento, $solicitacao, $andamentoSolicitacao);
  549.         }
  551.         $em->persist($andamentoSolicitacao);
  552.         $em->flush();
  554.         if($andamentoSolicitacao->getVisivel()){
  556.             $solicitacao = $andamentoSolicitacao->getSolicitacao();
  557.             $solicitacao->setStatusAtual($andamentoSolicitacao->getStatusSolicitacao());
  558.             $solicitacao->setUltimaInteracao('Atendimento');
  559.             $em->persist($solicitacao);
  560.             $em->flush();
  562.             $this->notificarCliente($andamentoSolicitacao->getSolicitacao());
  564.             if($status->getId() === 7){
  565.                 $this->createPesquisaSatisfacao($andamentoSolicitacao->getSolicitacao());
  566.             }
  568.         }
  570.         return $this->json(['status' => true]);
  571.     }
  573.     public function editAndamentoSolicitacaoAction(Request $request): JsonResponse
  574.     {
  575.         $em = $this->managerRegistry->getManager();
  576.         $data = json_decode( $request->getContent() );
  578.         $id = $data->id;
  579.         $status = $data->status;
  580.         $solicitacao = $data->solicitacao;
  581.         $mensagem = $data->mensagem;
  582.         $visivel = $data->visivel;
  584.         /** @var $andamentoSolicitacao AndamentoSolicitacao */
  585.         $andamentoSolicitacao = $em->getRepository(AndamentoSolicitacao::class)->findOneBy(['id' => $id]);
  586.         $status = $em->getRepository(StatusSolicitacao::class)->findOneBy(['id' => $status]);
  587.         if($status)
  588.             $andamentoSolicitacao->setStatusSolicitacao($status);
  590.         $andamentoSolicitacao->setMensagem($mensagem);
  591.         $andamentoSolicitacao->setVisivel($visivel);
  592.         $andamentoSolicitacao->setAlteradoPor($this->getUser());
  594.         if(in_array($status->getId(), [4,6])){
  595.             $agendamento = $andamentoSolicitacao->getAgendamento();
  596.             if(!$agendamento)
  597.                 $agendamento = new Agendamento();
  599.             $agendamento->setData(new \DateTime($data->agendamento->data));
  600.             $agendamento->setHora(new \DateTime($data->agendamento->periodo));
  601.             $agendamento->setObservacoes($data->agendamento->observacoes);
  602.             $agendamento->getProfissionais()->clear();
  603.             foreach ($data->agendamento->profissionais as $profissional){
  604.                 $profissional = $em->getRepository(Profissional::class)->find($profissional);
  605.                 if($profissional)
  606.                     $agendamento->getProfissionais()->add($profissional);
  607.             }
  608.             $em->persist($agendamento);
  609.             $em->flush();
  611.             $andamentoSolicitacao->setAgendamento($agendamento);
  613.             $em->persist($andamentoSolicitacao);
  614.             $em->flush();
  616.       /*      $resposta  = new RespostaSolicitacao();
  617.             $resposta->setMensagem('Sua vistoria foi agendada para o dia '.
  618.                 $this->formatDate($agendamento->getData()) . ' às '. $this->formatTime($agendamento->getHora())
  619.             );
  620.             $resposta->setRespondidoPor('atendimento');
  621.             $resposta->setAndamentoSolicitacao($andamentoSolicitacao);
  622.             $em->persist($resposta);
  623.             $em->flush();*/
  625.             //$this->createOrdemServico($agendamento);
  626.         }else{
  627.             if($andamentoSolicitacao->getAgendamento()){
  628.                 $em->remove($andamentoSolicitacao->getAgendamento());
  629.                 $em->flush();
  630.             }
  631.             $andamentoSolicitacao->setAgendamento(null);
  632.         }
  634.         $em->persist($andamentoSolicitacao);
  635.         $em->flush();
  637.         if($andamentoSolicitacao->getVisivel()){
  639.             $solicitacao = $andamentoSolicitacao->getSolicitacao();
  640.             $solicitacao->setStatusAtual($andamentoSolicitacao->getStatusSolicitacao());
  641.             $solicitacao->setUltimaInteracao('Atendimento');
  642.             $em->persist($solicitacao);
  643.             $em->flush();
  645.             $this->notificarCliente($andamentoSolicitacao->getSolicitacao());
  647.             if($status->getId() === 7){
  648.                 $this->createPesquisaSatisfacao($andamentoSolicitacao->getSolicitacao());
  649.             }
  651.         }
  655.         return $this->json(['status' => true]);
  656.     }
  658.     public function deleteAndamentoSolicitacaoAction(Request $request): JsonResponse
  659.     {
  660.         $em = $this->managerRegistry->getManager();
  662.         $data = json_decode( $request->getContent() );
  664.         $id = $data->id;
  665.         /** @var $andamento AndamentoSolicitacao */
  666.         $andamento = $em->getRepository(AndamentoSolicitacao::class)->findOneBy(['id' => $id]);
  667.         if(!$andamento)
  668.             return $this->json(['message' => 'Andamento não encontrado.'],400);
  670.         if($andamento->getAgendamento())
  671.             if(count($andamento->getAgendamento()->getOrdemServicos()->toArray()))
  672.                 return $this->json(['message' => 'Não é possível excluir o status atual pois ele possui uma ordem de serviço associada!'],400);
  674.         if($andamento->getAgendamento()){
  675.             $em->remove($andamento->getAgendamento());
  676.             $em->flush();
  677.         }
  679.         /** @var $solicitacao Solicitacao */
  680.         $solicitacao = $andamento->getSolicitacao();
  682.         $em->remove($andamento);
  683.         $em->flush();
  685.         /** @var $andamento AndamentoSolicitacao */
  686.         $andamento = $solicitacao->getAndamentoSolicitacao()->last();
  687.         $solicitacao->setStatusAtual(($andamento)? $andamento->getStatusSolicitacao() : null);
  688.         $em->persist($solicitacao);
  689.         $em->flush();
  691.         return $this->json([]);
  692.     }
  695.     /************************************************************************************************************
  696.      * Respostas
  697.      */
  699.     public function listRespostasSolicitacaoAction(Request $request): JsonResponse
  700.     {
  701.         $em = $this->managerRegistry->getManager();
  702.         $data = json_decode( $request->getContent() );
  703.         $andamento = $data->andamento;
  705.         $respostas = $em->getRepository(RespostaSolicitacao::class)->findBy(['andamentoSolicitacao' => $andamento], ['createdAt' => 'DESC']);
  707.         $response = [];
  708.         /** @var $resposta RespostaSolicitacao */
  709.         foreach ($respostas as $resposta) {
  710.             $response[] = [
  711.                 'id' => $resposta->getId(),
  712.                 'andamento' => $resposta->getAndamentoSolicitacao()->getId(),
  713.                 'assunto' => $resposta->getAssunto(),
  714.                 'mensagem' => $resposta->getMensagem(),
  715.                 'respondidoPor' => $resposta->getRespondidoPor(),
  716.                 'createdAt' => $resposta->getCreatedAt()? date_format($resposta->getCreatedAt(),"d/m/Y H:i:s"): null,
  717.                 'updatedAt' => $resposta->getUpdatedAt()? date_format($resposta->getUpdatedAt(),"d/m/Y H:i:s"): null,
  718.             ];
  719.         }
  721.         return $this->json($response);
  722.     }
  724.     public function getRespostaSolicitacaoAction(Request $request): JsonResponse
  725.     {
  726.         $this->validateAccess("listAction");
  728.         $id = $request->get('id');
  730.         /** @var $resposta RespostaSolicitacao */
  731.         $resposta = $this->managerRegistry->getRepository(RespostaSolicitacao::class)->findOneBy(['id' => $id]);
  733.         $response = [
  734.             'id' => $resposta->getId(),
  735.             'andamento' => $resposta->getAndamentoSolicitacao()->getId(),
  736.             'assunto' => $resposta->getAssunto(),
  737.             'mensagem' => $resposta->getMensagem(),
  738.             'respondidoPor' => $resposta->getRespondidoPor(),
  739.             'createdAt' => $resposta->getCreatedAt()? date_format($resposta->getCreatedAt(),"d/m/Y H:i:s"): null,
  740.             'updatedAt' => $resposta->getUpdatedAt()? date_format($resposta->getUpdatedAt(),"d/m/Y H:i:s"): null,
  741.         ];
  743.         return $this->json($response);
  744.     }
  746.     public function novaRespostaSolicitacaoAction(Request $request): JsonResponse
  747.     {
  748.         $em = $this->managerRegistry->getManager();
  751.         $solicitacao = $request->request->get('solicitacao');
  752.         $mensagem = $request->request->get('mensagem');
  754.         $anexos = [];
  755.         for ($i=0; $i<10; $i++){
  756.             $file = $request->files->get('file-'.$i);
  757.             if($file)
  758.                 $anexos[] = $file;
  759.         }
  761.         if(!$mensagem)
  762.             return $this->json(['message' => 'Mensagem não encontrado.'],400);
  764.         $solicitacao = $em->getRepository(Solicitacao::class)->find($solicitacao);
  765.         if(!$solicitacao)
  766.             return $this->json(['message' => 'Solicitação não encontrado.'],400);
  768.         $resposta = new RespostaSolicitacao();
  769.         $resposta->setAndamentoSolicitacao($solicitacao->getAndamentoSolicitacao()->last());
  770.         $resposta->setMensagem($mensagem);
  771.         $resposta->setRespondidoPor('atendimento');
  772.         $resposta->setAdminResposta($this->getUser());
  774.         if($anexos){
  775.             /** Cria Galeria caso não exista */
  776.             $resposta->setAnexos($this->mediaService->createGallery());
  777.             /** Cria as Medias e retorna array */
  778.             $medias = $this->mediaService->createMultipleMedia($anexos);
  779.             /** Adicionar medias em galeria */
  780.             $this->mediaService->addMediaInGallery($medias, $resposta->getAnexos());
  781.         }
  783.         $em->persist($resposta);
  784.         $em->flush();
  786.         if($resposta->getAndamentoSolicitacao()->getVisivel()){
  788.             $solicitacao = $resposta->getAndamentoSolicitacao()->getSolicitacao();
  789.             $solicitacao->setUltimaInteracao('Atendimento');
  790.             $em->persist($solicitacao);
  791.             $em->flush();
  793.             $this->notificarCliente($solicitacao);
  794.         }
  796.         return $this->json(['status' => true]);
  797.     }
  799.     public function editRespostaSolicitacaoAction(Request $request): JsonResponse
  800.     {
  801.         $em = $this->managerRegistry->getManager();
  802.         $data = json_decode( $request->getContent() );
  804.         $id = $data->id;
  805.         $andamento = $data->andamento;
  806.         $mensagem = $data->mensagem;
  808.         /** @var $resposta RespostaSolicitacao */
  809.         $resposta = $em->getRepository(RespostaSolicitacao::class)->findOneBy(['id' => $id]);
  811.         $resposta->setMensagem($mensagem);
  813.         $em->persist($resposta);
  814.         $em->flush();
  817.         if($resposta->getAndamentoSolicitacao()->getVisivel()){
  818.             $solicitacao = $resposta->getAndamentoSolicitacao()->getSolicitacao();
  819.             $solicitacao->setUltimaInteracao('Atendimento');
  820.             $em->persist($solicitacao);
  821.             $em->flush();
  823.             $this->notificarCliente($solicitacao);
  824.         }
  826.         return $this->json(['status' => true]);
  827.     }
  829.     public function deleteRespostaSolicitacaoAction(Request $request): JsonResponse
  830.     {
  831.         $em = $this->managerRegistry->getManager();
  833.         $data = json_decode( $request->getContent() );
  835.         $id = $data->id;
  836.         $resposta = $em->getRepository(RespostaSolicitacao::class)->findOneBy(['id' => $id]);
  837.         if(!$resposta)
  838.             return $this->json(['message' => 'Resposta não encontrado.'],400);
  840.         $em->remove($resposta);
  841.         $em->flush();
  843.         return $this->json([]);
  844.     }
  846.     /************************************************************************************************************
  847.      * Ordem de Serviço
  848.      */
  850.     public function apiListOrdemServicoAction(Request $request): JsonResponse
  851.     {
  852.         $em = $this->managerRegistry->getManager();
  853.         $data = json_decode( $request->getContent() );
  854.         $solicitacao = $data->solicitacao;
  856.         $andamentos = $em->getRepository(AndamentoSolicitacao::class)->findBy(['solicitacao' => $solicitacao], ['createdAt' => 'DESC']);
  858.         $response = [];
  859.         /** @var $andamentoSolicitacao AndamentoSolicitacao */
  860.         foreach ($andamentos as $andamentoSolicitacao) {
  861.             if(!$andamentoSolicitacao->getAgendamento())
  862.                 continue;
  864.             /** @var $ordemServico OrdemServico */
  865.             foreach ($andamentoSolicitacao->getAgendamento()->getOrdemServicos() as $ordemServico){
  866.                 $response[] = [
  867.                     'id' => $ordemServico->getId(),
  868.                     'codigo' => $ordemServico->getCodigo(),
  869.                     'profissional' => $ordemServico->getProfissional()->getNomecompleto(),
  870.                     'status' => $ordemServico->getStatus(),
  871.                     'dataAgendamento' => $this->formatDate($ordemServico->getData()),
  872.                     'horaAgendamento' => $this->formatTime($ordemServico->getHora()),
  873.                     'createdAt' => $this->formatDateTime($ordemServico->getCreatedAt()),
  874.                     'updatedAt' => $this->formatDateTime($ordemServico->getUpdatedAt()),
  875.                 ];
  876.             }
  877.         }
  879.         return $this->json($response);
  880.     }
  882.     public function apiGetOrdemServicoAction(Request $request): JsonResponse
  883.     {
  884.         $this->validateAccess("listAction");
  886.         $id = $request->get('id');
  888.         /** @var $andamentoSolicitacao AndamentoSolicitacao */
  889.         $ordemServico = $this->managerRegistry->getRepository(OrdemServico::class)->findOneBy(['id' => $id]);
  890.         if(!$ordemServico)
  891.             return $this->json(['status' => false, 'message' => 'Ordem de serviço não encontrada!']);
  893.         /** @var Solicitacao $solicitacao */
  894.         $solicitacao = $ordemServico->getAgendamento()->getAndamento()->getSolicitacao();
  896.         $response = [
  897.             'id' => $ordemServico->getId(),
  898.             'codigo' => $ordemServico->getCodigo(),
  899.             'status' => $ordemServico->getStatus(),
  900.             'dataAgendamento' => $this->formatDate($ordemServico->getData()),
  901.             'horaAgendamento' => $this->formatTime($ordemServico->getHora()),
  902.             'mensagemDinamica' => $ordemServico->getAgendamento()->getObservacoes(),
  903.             'cliente' => (!$solicitacao->getCliente())? null: [
  904.                 'id' => $solicitacao->getCliente()->getId(),
  905.                 'nome' => $solicitacao->getCliente()->getNomeCompleto(),
  906.                 'telefone' => $solicitacao->getCliente()->getTelefone(),
  907.                 'email' => $solicitacao->getCliente()->getEmail(),
  908.             ],
  909.             'unidade' => (!$solicitacao->getUnidade())? null: [
  910.                 'empreendimento' => $solicitacao->getUnidade()->getBloco()->getEmpreendimento()->getNome(),
  911.                 'bloco' => $solicitacao->getUnidade()->getBloco()->getBloco(),
  912.                 'unidade' => $solicitacao->getUnidade()->getUnidade(),
  913.             ],
  914.             'agendamento' => (!$ordemServico->getAgendamento())? null: [
  915.                 'id'=> $ordemServico->getAgendamento()->getId()
  916.             ],
  917.             'profissional' => (!$ordemServico->getProfissional())? null: [
  918.                 'id'=> $ordemServico->getProfissional()->getId(),
  919.                 'nomeCompleto'=> $ordemServico->getProfissional()->getNomecompleto(),
  920.                 'email'=> $ordemServico->getProfissional()->getEmail(),
  921.             ],
  922.             'descricao' => $ordemServico->getDescricao(),
  923.             'anexosPreparacao' => $this->mediaService->getGalleryJson($ordemServico->getAnexosPreparacao()),
  924.             'anexosTrabalhoAndamento' => $this->mediaService->getGalleryJson($ordemServico->getAnexosTrabalhoAndamento()),
  925.             'anexosTrabalhoFinalizado' => $this->mediaService->getGalleryJson($ordemServico->getAnexosTrabalhoFinalizado()),
  926.             'assinaturaCliente' => $this->mediaService->getMediaJson($ordemServico->getAssinaturaCliente()),
  927.             'assinaturaProfissional' => $this->mediaService->getMediaJson($ordemServico->getAssinaturaProfissional()),
  928.             'aCaminho' => $this->formatDateTime($ordemServico->getDataACaminho()),
  929.             'inicioAtendimento' => $this->formatDateTime($ordemServico->getDataIniciarAtendimento()),
  930.             'finalAtendimento' => $this->formatDateTime($ordemServico->getDataFinalAtendimento()),
  931.             'criadoEm' => $this->formatDateTime($ordemServico->getCreatedAt()),
  932.             'atualizadoEm' => $this->formatDateTime($ordemServico->getUpdatedAt()),
  933.         ];
  935.         return $this->json($response);
  936.     }
  938.     public function deleteOrdemServicoAction(Request $request): JsonResponse
  939.     {
  940.         $em = $this->managerRegistry->getManager();
  942.         $id = $request->get('id');
  943.         $ordemServico = $em->getRepository(OrdemServico::class)->findOneBy(['id' => $id]);
  944.         if(!$ordemServico)
  945.             return $this->json(['message' => 'Ordem de serviço não encontrado.'],400);
  947.         $em->remove($ordemServico);
  948.         $em->flush();
  950.         return $this->json([]);
  951.     }
  954.     /************************************************************************************************************
  955.      * Chat
  956.      */
  958.     public function chatAction(Request $request): JsonResponse
  959.     {
  960.         $em = $this->managerRegistry->getManager();
  962.         $solicitacao = $request->get('solicitacao');
  964.         $response = $this->getDataChat($solicitacao);
  966.         return new JsonResponse($response);
  967.     }
  969.     public function getDataChat($solicitacaoId)
  970.     {
  971.         $em = $this->managerRegistry->getManager();
  973.         $andamentos = $em->getRepository(AndamentoSolicitacao::class)->findBy(['solicitacao' => $solicitacaoId], ['createdAt' => 'ASC']);
  975.         $response = [];
  976.         /** @var $andamento AndamentoSolicitacao */
  977.         foreach ($andamentos as $andamento) {
  979.             $respostasData = $em->getRepository(RespostaSolicitacao::class)->findBy(['andamentoSolicitacao' => $andamento->getId()], ['createdAt' => 'ASC']);
  981.             $respostas = [];
  982.             /** @var $resposta RespostaSolicitacao */
  983.             foreach ($respostasData as $resposta) {
  984.                 $respostas[] = [
  985.                     'id' => $resposta->getId(),
  986.                     'assunto' => $resposta->getAssunto(),
  987.                     'mensagem' => $resposta->getMensagem(),
  988.                     'respondidoPor' => $resposta->getRespondidoPor(),
  989.                     'criadoEm' => $this->formatDateTime($resposta->getCreatedAt()) ,
  990.                     'atualizadoEm' => $this->formatDateTime($resposta->getUpdatedAt()),
  991.                     'anexos' => $this->mediaService->getGalleryJson($resposta->getAnexos()),
  992.                 ];
  993.             }
  995.             $profissionais = [];
  996.             if($andamento->getAgendamento())
  997.                 foreach ($andamento->getAgendamento()->getProfissionais() as $profissional){
  998.                     $profissionais[] = $profissional->getId();
  999.                 }
  1001.             $response[] = [
  1002.                 'id' => $andamento->getId(),
  1003.                 'status' => !$andamento->getStatusSolicitacao()? null: [
  1004.                     'id' => $andamento->getStatusSolicitacao()->getId(),
  1005.                     'status' => $andamento->getStatusSolicitacao()->getStatus(),
  1006.                 ],
  1007.                 'assunto' => $andamento->getAssunto(),
  1008.                 'mensagem' => $andamento->getMensagem(),
  1009.                 'visivel' =>  $andamento->getVisivel(),
  1010.                 'criadoEm' =>  $this->formatDateTime($andamento->getCreatedAt()),
  1011.                 'atualizadoEm' => $this->formatDateTime($andamento->getUpdatedAt()) ,
  1012.                 'agendamento' => !$andamento->getAgendamento()? null : [
  1013.                     'id' => $andamento->getAgendamento()->getId(),
  1014.                     'data' => date_format($andamento->getAgendamento()->getData(), 'Y-m-d'),
  1015.                     'periodo' => date_format($andamento->getAgendamento()->getData(), 'h:i'),
  1016.                     'observacoes' => $andamento->getAgendamento()->getObservacoes(),
  1017.                     'profissionais' => $profissionais,
  1018.                 ],
  1019.                 'respostas' => $respostas,
  1020.             ];
  1021.         }
  1023.         return $response;
  1024.     }
  1028.     /************************************************************************************************************
  1029.      * Aux
  1030.      */
  1032.     public function createPesquisaSatisfacao(Solicitacao $solicitacao)
  1033.     {
  1034.         $pesquisa = new PesquisaSatisfacao();
  1035.         $pesquisa->setSolicitacao($solicitacao);
  1036.         $pesquisa->setCliente($solicitacao->getCliente());
  1038.         $this->managerRegistry->getManager()->persist($pesquisa);
  1039.         $this->managerRegistry->getManager()->flush();
  1041.         $mail = $this->serviceEmail->getEmail();
  1042.         $mail->addAddress($solicitacao->getCliente()->getEmail());
  1043.         $mail->Subject = 'Aguardando Avaliação';
  1045.         $mail->Body = $this->renderTemplateEmail('emails/solicitacao/notificacao_cliente_pesquisa_satisfacao.html.twig', [
  1046.             'solicitacao' => $solicitacao,
  1047.         ]);
  1049.         $mail->send();
  1050.     }
  1052.     public function notificarCliente(Solicitacao $solicitacao): void
  1053.     {
  1054.         $mail = $this->serviceEmail->getEmail();
  1055.         $mail->addAddress($solicitacao->getCliente()->getEmail());
  1056.         $mail->Subject = 'Atualização de Solicitação';
  1058.         $mail->Body = $this->renderTemplateEmail('emails/solicitacao/notificacao_cliente_atualizacao_solicitacao.html.twig', [
  1059.             'solicitacao' => $solicitacao,
  1060.         ]);
  1062.         $mail->send();
  1063.     }
  1065.     public function notificarResponsavelAtendimento(Solicitacao $solicitacao): void
  1066.     {
  1067.         /*$mail = $this->serviceEmail->getEmail();
  1068.         $mail->addAddress($solicitacao->getResponsavelAtendimento()->getEmail());
  1069.         $mail->Subject = 'Atribuição de Solicitação';
  1071.         $mail->Body = $this->renderTemplateEmail('emails/solicitacao/agendamento/notificacao_reponsavelAtendimento.html.twig', [
  1072.             'solicitacao' => $solicitacao,
  1073.         ]);
  1075.         $mail->send();*/
  1076.     }
  1079.     public function createOrdemServico(Agendamento $agendamento, Solicitacao $solicitacao, AndamentoSolicitacao $andamento): void
  1080.     {
  1081.         $em = $this->managerRegistry->getManager();
  1083.         $empresa = $this->serviceEmail->getEmpresa();
  1085.         /** @var $profissional Profissional */
  1086.         foreach ($agendamento->getProfissionais() as $profissional) {
  1088.             $ordemServico = new OrdemServico();
  1089.             $ordemServico->setAgendamento($agendamento);
  1090.             $ordemServico->setData($agendamento->getData());
  1091.             $ordemServico->setHora($agendamento->getHora());
  1092.             $ordemServico->setProfissional($profissional);
  1093.             $ordemServico->setStatus('Agendado');
  1094.             $em->persist($ordemServico);
  1095.             $em->flush();
  1096.             $ordemServico->setCodigo("DIN00" . $ordemServico->getId() . "-1");
  1097.             $em->persist($ordemServico);
  1098.             $em->flush();
  1100.             $resposta  = new RespostaSolicitacao();
  1101.             $resposta->setMensagem('Prezado(a) Senhor(a) '.$solicitacao->getCliente()->getNomeCompleto().'.
  1102.             Agendamos para o dia '.$this->formatDate($agendamento->getData()).' às '.date_format($agendamento->getHora(),'H:i').'h a visita técnica.
  1103.             Havendo qualquer dúvida, estamos à total disposição.
  1104.             Atenciosamente,
  1105.             Pedro Pachion');
  1106.             $resposta->setRespondidoPor('atendimento');
  1107.             $resposta->setAndamentoSolicitacao($andamento);
  1108.             $em->persist($resposta);
  1109.             $em->flush();
  1111.             $urlProfissional = ( (substr($empresa->getUrlCliente(), -1) == '/')? $empresa->getUrlCliente(): $empresa->getUrlCliente().'/')
  1112.                 .'os/'.$profissional->getId().'/'.str_replace(' ', '-', $profissional->getNomecompleto());
  1114.             /** START Fluxo SMS */
  1115.             $phone = ($profissional->getTelefone1())?: $profissional->getTelefone2();
  1116.             $nomeProfissional = explode(' ', $profissional->getNomecompleto());
  1117.                         
  1118.             $message = "Olá ". $nomeProfissional[0] .", a OS ". $ordemServico->getCodigo() .
  1119.                 " está disponível para a execução, acesse: ".
  1120.                 $urlProfissional . " Att, " . $empresa->getNome();
  1121.             
  1122.             if($phone)
  1123.                 $this->serviceComteleSMS->sendSMS($phone,$message);
  1124.             /** END Fluxo SMS */
  1126.             /** START Fluxo Email */
  1127.             $mail = $this->serviceEmail->getEmail();
  1128.             $mail->addAddress($profissional->getEmail());
  1129.             if($solicitacao->getResponsavelAtendimento())
  1130.                 $mail->addReplyTo($solicitacao->getResponsavelAtendimento()->getEmail());
  1131.             $mail->Subject = 'Nova Ordem de Serviço';
  1132.             $mail->Body = $this->renderTemplateEmail('emails/solicitacao/agendamento/notificacao_profissional_os_criada.html.twig', [
  1133.                 'profissional' => $profissional,
  1134.                 'os' => $ordemServico,
  1135.                 'urlProfissional' => $urlProfissional,
  1136.             ]);
  1137.             $mail->send();
  1138.             /** END Fluxo Email */
  1140.         }
  1143.     }
  1146.     public function apiDashboardSolicitacoesAction(Request $request)
  1147.     {
  1148.         $em = $this->managerRegistry->getManager();
  1150.         $empreendimentosFilter = ($request->query->get('empreendimentos'))? explode(",", $request->query->get('empreendimentos')): false;
  1151.         $dataAgendamentoDe = ($request->query->get('dataAgendamentoDe'))? new \DateTime($request->query->get('dataAgendamentoDe')): false;
  1152.         $dataAgendamentoAte = ($request->query->get('dataAgendamentoAte'))? new \DateTime($request->query->get('dataAgendamentoAte')): false;
  1155.         $solicitacoes = $em->getRepository(Solicitacao::class)->findBy(['statusAtual' => 4]);
  1157.         $solicitacoesAgendadas = [];
  1158.         /** @var $solicitacao Solicitacao */
  1159.         foreach ($solicitacoes as $solicitacao) {
  1161.             $andamento = $solicitacao->getAndamentoSolicitacao()->last();
  1162.             /** @var $agendamento Agendamento */
  1163.             $agendamento = $andamento->getAgendamento();
  1164.             if(!$agendamento)
  1165.                 continue;
  1167.             $profissionais = "";
  1168.             foreach ($agendamento->getProfissionais() as $profissional) {
  1169.                 $profissionais .= $profissional->getNomecompleto() . ', ';
  1170.             }
  1172.             $dateNow = new \DateTime('now');
  1174.             /*if($agendamento->getData() < $dateNow)
  1175.                 continue;*/
  1177.             if($empreendimentosFilter && !in_array($solicitacao->getUnidade()->getBloco()->getEmpreendimento()->getId(), $empreendimentosFilter))
  1178.                 continue;
  1180.             if($dataAgendamentoDe && ($dataAgendamentoDe > $agendamento->getData()))
  1181.                 continue;
  1183.             if($dataAgendamentoAte && ($dataAgendamentoAte < $agendamento->getData()))
  1184.                 continue;
  1186.             $solicitacoesAgendadas[] = [
  1187.                 'id' => $solicitacao->getId(),
  1188.                 'codigo' => $solicitacao->getCodigo(),
  1189.                 'empreendimento'=> $solicitacao->getUnidade()->getBloco()->getEmpreendimento()->getNome(),
  1190.                 'bloco' => $solicitacao->getUnidade()->getBloco()->getBloco(),
  1191.                 'unidade' => $solicitacao->getUnidade()->getUnidade(),
  1192.                 'cliente' => $solicitacao->getCliente()->getNomeCompleto(),
  1193.                 'profissional' => $profissionais,
  1194.                 'dataAgendamento' => date_format($agendamento->getData(), 'd/m/Y') . ' ' .date_format($agendamento->getHora(), 'H:i'),
  1195.                 'mensagem' => $solicitacao->getMensagem(),
  1196.             ];
  1197.         }
  1199.         $empreendimentos = [];
  1200.         foreach ($em->getRepository(Empreendimento::class)->findBy([], ['nome' => 'ASC']) as $empreendimento) {
  1201.             $empreendimentos[] = [
  1202.                 'id' => $empreendimento->getId(),
  1203.                 'name' => $empreendimento->getNome(),
  1204.             ];
  1205.         }
  1207.         return $this->json([
  1208.            'solicitacoesAgendadas' => $solicitacoesAgendadas,
  1209.             'empreendimentos' => $empreendimentos,
  1210.         ]);
  1211.     }
  1217. }