Reativa o atendimento para o mesmo serviço e mesma prioridade.
Só pode reativar atendimentos que foram: Cancelados ou Não Compareceu.

@param Atendimento $atendimento
@param Unidade     $unidade

@return bool
542886
public function reativar(Atendimento $atendimento, Unidade $unidade)
    {
        $this->dispatcher->createAndDispatch('attending.pre-reactivate', $atendimento, true);

        // reativa apenas se estiver finalizada (data fim diferente de nulo)
        $success = $this->storage
            ->getManager()
            ->createQueryBuilder()
            ->update(Atendimento::class, 'e')
            ->set('e.status', ':status')
            ->set('e.dataFim', ':data')
            ->set('e.usuario', ':usuario')
            ->where('e.id = :id')
            ->andWhere('e.unidade = :unidade')
            ->andWhere('e.status IN (:statuses)')
            ->setParameters([
                'status'   => self::SENHA_EMITIDA,
                'data'     => null,
                'usuario'  => null,
                'id'       => $atendimento,
                'unidade'  => $unidade,
                'statuses' => [self::SENHA_CANCELADA, self::NAO_COMPARECEU],
            ])
            ->getQuery()
            ->execute() > 0;

        if ($success) {
            $this->storage->getManager()->refresh($atendimento);
            $this->dispatcher->createAndDispatch('attending.reactivate', $atendimento, true);
        }

        return $success;
    }
549220
public function delete($id = null) {
		$this->UnidadDeMedida->id = $id;
		if (!$this->UnidadDeMedida->exists()) {
			throw new NotFoundException(__('Unidad De Medida Inválido'));
		}
		$this->request->allowMethod('post', 'delete');
		if ($this->UnidadDeMedida->delete()) {
			$this->Flash->success(__('Se ha borrado la Unidad de Medida.'));
		} else {
			$this->Flash->error(__('No se ha podido eliminar la Unidad de Medida'), 'Risto.flash_error');
		}
		return $this->redirect($this->referer());
	}
1310993
private function mudaStatusAtendimento(Atendimento $atendimento, $statusAtual, $novoStatus, $campoData = null)
    {
        $em = $this->getDoctrine()->getManager();
        
        $cond = '';
        if ($campoData !== null) {
            $cond = ", e.$campoData = :data";
        }
        if (!is_array($statusAtual)) {
            $statusAtual = [$statusAtual];
        }
        
        $data = (new DateTime())->format('Y-m-d H:i:s');
        
        // atualizando atendimento
        $query = $em->createQuery("
            UPDATE
                Novosga\Entity\Atendimento e
            SET
                e.status = :novoStatus $cond
            WHERE
                e.id = :id AND
                e.status IN (:statusAtual)
        ");
        if ($campoData !== null) {
            $query->setParameter('data', $data);
        }
        $query->setParameter('novoStatus', $novoStatus);
        $query->setParameter('id', $atendimento->getId());
        $query->setParameter('statusAtual', $statusAtual);

        return $query->execute() > 0;
    }
676726
protected function checkIfCartIsValid(UserInterface $user, ApiOrderInterface $cart, $locale)
    {
        if (count($cart->getItems()) < 1) {
            throw new OrderException('Empty Cart');
        }
    }
15458
public function servicos(Usuario $usuario, Unidade $unidade)
    {
        $servicos = $this->storage
            ->getManager()
            ->createQueryBuilder()
            ->select('e')
            ->from(ServicoUsuario::class, 'e')
            ->join('e.servico', 's')
            ->where('e.usuario = :usuario')
            ->andWhere('e.unidade = :unidade')
            ->andWhere('s.ativo = TRUE')
            ->orderBy('s.nome', 'ASC')
            ->setParameters([
                'usuario' => $usuario,
                'unidade' => $unidade
            ])
            ->getQuery()
            ->getResult();
        
        return $servicos;
    }
116821
public function filaServico(Unidade $unidade, Servico $servico)
    {
        $builder = $this->builder();
        
        $params = [
            'status'  => AtendimentoService::SENHA_EMITIDA,
            'unidade' => $unidade,
            'servico' => $servico,
        ];
        
        $builder
            ->where('atendimento.status = :status')
            ->andWhere('atendimento.unidade = :unidade')
            ->andWhere('atendimento.servico = :servico');
        
        $this->applyOrders($builder, $unidade);

        $rs = $builder
            ->setParameters($params)
            ->getQuery()
            ->getResult();

        return $rs;
    }
1241056
public function cancelar(Atendimento $atendimento)
    {
        if ($atendimento->getDataFim() !== null) {
            throw new Exception('Erro ao tentar cancelar um serviço já encerrado.');
        }
        
        $this->dispatcher->createAndDispatch('attending.pre-cancel', $atendimento, true);
        
        $now = new DateTime();
        $atendimento->setDataFim($now);
        
        if ($atendimento->getDataChegada()) {
            $tempoPermanencia = $atendimento->getDataFim()->diff($atendimento->getDataChegada());
        } else {
            $tempoPermanencia = $atendimento->getDataFim()->diff($now);
        }
        
        if ($atendimento->getDataInicio()) {
            $tempoAtendimento = $atendimento->getDataFim()->diff($atendimento->getDataInicio());
        } else {
            $tempoAtendimento = null;
        }
        
        $atendimento->setTempoPermanencia($tempoPermanencia);
        $atendimento->setTempoAtendimento($tempoAtendimento);
        $atendimento->setStatus(self::SENHA_CANCELADA);
        
        $em = $this->storage->getManager();
        $em->merge($atendimento);
        $em->flush();

        $this->dispatcher->createAndDispatch('attending.cancel', $atendimento, true);
    }
784053
public function index(
        Request $request,
        ServicoService $servicoService,
        SecurityService $securityService,
        UsuarioService $usuarioService,
        TranslatorInterface $translator
    ) {
        $em = $this->getDoctrine()->getManager();
        
        $usuario = $this->getUser();
        $unidade = $usuario->getLotacao()->getUnidade();
        
        // locais disponiveis
        $locais = $em
            ->getRepository(Local::class)
            ->findBy([], ['nome' => 'ASC']);

        // usuarios da unidade
        $usuarios = $em
            ->getRepository(Usuario::class)
            ->findByUnidade($unidade);
        
        $servicosUnidade = $servicoService->servicosUnidade($unidade);
        
        $usuariosArray = array_map(function (Usuario $usuario) use (
            $em,
            $unidade,
            $servicosUnidade,
            $usuarioService
        ) {
            $servicosUsuario = $em
                ->getRepository(ServicoUsuario::class)
                ->getAll($usuario, $unidade);
            
            $data  = $usuario->jsonSerialize();
            $data['servicos'] = [];
                    
            foreach ($servicosUnidade as $servicoUnidade) {
                foreach ($servicosUsuario as $servicoUsuario) {
                    $idA = $servicoUsuario->getServico()->getId();
                    $idB = $servicoUnidade->getServico()->getId();
                    
                    if ($idA === $idB) {
                        $data['servicos'][] = [
                            'id'    => $servicoUnidade->getServico()->getId(),
                            'sigla' => $servicoUnidade->getSigla(),
                            'nome'  => $servicoUnidade->getServico()->getNome(),
                            'peso'  => $servicoUsuario->getPeso(),
                        ];
                    }
                }
            }
            
            $tipoMeta                = $usuarioService->meta($usuario, UsuarioService::ATTR_ATENDIMENTO_TIPO);
            $data['tipoAtendimento'] = $tipoMeta ? $tipoMeta->getValue() : FilaService::TIPO_TODOS;
            
            $numeroMeta      = $usuarioService->meta($usuario, UsuarioService::ATTR_ATENDIMENTO_LOCAL);
            $data['numero']  = $numeroMeta ? (int) $numeroMeta->getValue() : null;
            
            return $data;
        }, $usuarios);
        
        $tiposAtendimento = $this->getTiposAtendimento($translator);
        
        $form          = $this->createForm(ServicoUnidadeType::class);
        $inlineForm    = $this->createForm(ServicoUnidadeType::class);
        $impressaoForm = $this->createForm(ImpressaoType::class, $unidade->getImpressao());

        return $this->render('@NovosgaSettings/default/index.html.twig', [
            'usuario'          => $usuario,
            'unidade'          => $unidade,
            'locais'           => $locais,
            'usuarios'         => $usuariosArray,
            'tiposAtendimento' => $tiposAtendimento,
            'form'             => $form->createView(),
            'inlineForm'       => $inlineForm->createView(),
            'impressaoForm'    => $impressaoForm->createView(),
            'wsSecret'         => $securityService->getWebsocketSecret(),
        ]);
    }
828598
public function ajaxUpdate(Request $request, AtendimentoService $atendimentoService)
    {
        $em = $this->getDoctrine()->getManager();
        
        $envelope = new Envelope();
        $usuario = $this->getUser();
        $unidade = $usuario->getLotacao()->getUnidade();
        $repo    = $em->getRepository(Atendimento::class);
        
        if ($unidade) {
            $ids = array_filter(explode(',', $request->get('ids')), function ($i) {
                return $i > 0;
            });
            
            $senhas = [];
            if (count($ids)) {
                // total senhas do servico (qualquer status)
                $rs = $repo->countByServicos($unidade, $ids);
                foreach ($rs as $r) {
                    $senhas[$r['id']] = ['total' => $r['total'], 'fila' => 0];
                }
                
                // total senhas esperando
                $rs = $repo->countByServicos($unidade, $ids, AtendimentoService::SENHA_EMITIDA);
                foreach ($rs as $r) {
                    $senhas[$r['id']]['fila'] = $r['total'];
                }
                
                // ultima senha
                $ultimoAtendimento = $repo->getUltimo($unidade);

                $data = [
                    'ultima'   => $ultimoAtendimento,
                    'servicos' => $senhas,
                ];
                
                $envelope->setData($data);
            }
        }

        return $this->json($envelope);
    }
774767
private function _checkUniqueID(Certificate $cert): bool
    {
        if (!$cert->tbsCertificate()->hasIssuerUniqueID()) {
            return false;
        }
        $uid = $cert->tbsCertificate()
            ->issuerUniqueID()
            ->string();
        if ($this->_issuerUID->string() != $uid) {
            return false;
        }
        return true;
    }
736840
public function checkSubscription($services = 0)
    {
        $options = array();

        if ($services & Services::ACQUIA_SEARCH) {
            $options = array(
                'search_version' => array('acquia/acquia-search-sdk' => Version::RELEASE)
            );
        }

        return $this->getSubscription($options);
    }
1085102
public static function hasInternalExpireTime($unserializedValue)
    {
        return (
            is_array($unserializedValue)
            && array_key_exists('v', $unserializedValue)
            && array_key_exists('s', $unserializedValue)
            && array_key_exists('ts', $unserializedValue)
        );
    }
929879
public function setDestination($destination)
  {
    if(!preg_match('/[\/]$/', $destination))
      $destination .= '/';

    if(!is_dir($destination))
      throw new \InvalidArgumentException('Diretório $destination não encontrado.');

    $this->destination = $destination;
  }
686234
public function addServico(Request $request, ServicoService $servicoService)
    {
        $json    = $request->getContent();
        $data    = json_decode($json, true);
        $ids     = $data['ids'] ?? [];
        $unidade = $this->getUser()->getLotacao()->getUnidade();
        $em      = $this->getDoctrine()->getManager();
        
        if (!is_array($ids)) {
            $ids = [];
        }
        
        // locais disponiveis
        $locais = $em
            ->getRepository(Local::class)
            ->findBy([], ['nome' => 'ASC']);
        
        if (empty($locais)) {
            throw new \Exception('Nenhum local disponível');
        }

        $count = count($servicoService->servicosUnidade($unidade));
        
        foreach ($ids as $id) {
            $servico = $em->find(Servico::class, $id);

            if ($servico) {
                $sigla = $this->novaSigla(++$count);

                $su = new ServicoUnidade();
                $su->setUnidade($unidade);
                $su->setServico($servico);
                $su->setIncremento(1);
                $su->setLocal($locais[0]);
                $su->setMensagem('');
                $su->setNumeroInicial(1);
                $su->setPeso(1);
                $su->setPrioridade(true);
                $su->setSigla($sigla);
                $su->setAtivo(false);
                
                $contador = $this
                    ->getDoctrine()
                    ->getManager()
                    ->getRepository(Contador::class)
                    ->findOneBy([
                        'unidade' => $unidade,
                        'servico' => $servico,
                    ]);
                
                if (!$contador) {
                    $contador = new Contador();
                    $contador->setServico($servico);
                    $contador->setUnidade($unidade);
                    $contador->setNumero($su->getNumeroInicial());
                    $em->persist($contador);
                } else {
                    $contador->setNumero($su->getNumeroInicial());
                    $em->merge($contador);
                }

                $em->persist($su);
                $em->flush();
            }
        }
        
        $envelope = new Envelope();
        
        return $this->json($envelope);
    }
431581
public function index(Request $request, ServicoService $servicoService, SecurityService $securityService)
    {
        $em      = $this->getDoctrine()->getManager();
        $usuario = $this->getUser();
        $unidade = $usuario->getLotacao()->getUnidade();
        
        $prioridades = $em->getRepository(Prioridade::class)->findAtivas();
        $servicos    = $servicoService->servicosUnidade($unidade, ['ativo' => true]);
        
        return $this->render('@NovosgaTriage/default/index.html.twig', [
            'usuario'     => $usuario,
            'unidade'     => $unidade,
            'servicos'    => $servicos,
            'prioridades' => $prioridades,
            'wsSecret'    => $securityService->getWebsocketSecret(),
        ]);
    }
1318232
public function setCarteira($carteira)
    {
        if (!in_array($carteira, $this->getCarteiras())) {
            throw new \Exception("Carteira não disponível!");
        }
        $this->carteira = $carteira;

        return $this;
    }
1284823
def configurar_interface_de_rede(self, configuracao):
        
        resp = self._http_post('configurarinterfacederede',
                configuracao=configuracao.documento())
        conteudo = resp.json()
        return RespostaSAT.configurar_interface_de_rede(conteudo.get('retorno'))