Retorna a fila de atendimentos do usuario.

@param Unidade          $unidade
@param Usuario          $usuario
@param ServicoUsuario[] $servicosUsuario
@param string           $tipoFila
@param int              $maxResults

@return array
501806
public function filaAtendimento(
        Unidade $unidade,
        Usuario $usuario,
        array $servicosUsuario,
        $tipoFila = self::TIPO_TODOS,
        $maxResults = 0
    ) {
        $ids = [];
        foreach ($servicosUsuario as $servico) {
            if ($servico->getUsuario()->getId() === $usuario->getId()) {
                $ids[]   = $servico->getServico()->getId();
            }
        }
        
        if (empty($ids)) {
            return [];
        }
        
        $builder = $this
            ->builder()
            ->join(
                ServicoUsuario::class,
                'servicoUsuario',
                'WITH',
                'servicoUsuario.servico = servico AND servicoUsuario.usuario = :usuario'
            )
            ->andWhere('(atendimento.usuario IS NULL OR atendimento.usuario = :usuario)')
            ->andWhere('atendimento.status = :status')
            ->andWhere('atendimento.unidade = :unidade')
            ->andWhere('servico.id IN (:servicos)');
        
        // se nao atende todos, filtra pelo tipo de atendimento
        switch ($tipoFila) {
            case self::TIPO_NORMAL:
            case self::TIPO_PRIORIDADE:
                $s = ($tipoFila === self::TIPO_NORMAL) ? '=' : '>';
                $where = "prioridade.peso $s 0";
                $builder->andWhere($where);
                break;
            case self::TIPO_AGENDAMENTO:
                $builder->andWhere("atendimento.dataAgendamento IS NOT NULL");
                break;
        }
        
        $params = [
            'status'   => AtendimentoService::SENHA_EMITIDA,
            'unidade'  => $unidade,
            'usuario'  => $usuario,
            'servicos' => $ids,
        ];
        
        $this->applyOrders($builder, $unidade, $usuario);

        $query = $builder
            ->setParameters($params)
            ->getQuery();

        if ($maxResults > 0) {
            $query->setMaxResults($maxResults);
        }

        return $query->getResult();
    }
517766
public static function get_user_contacts(int $userid, int $limitfrom = 0, int $limitnum = 0) {
        global $DB;

        $sql = "SELECT *
                  FROM {message_contacts} mc
                 WHERE mc.userid = ? OR mc.contactid = ?
              ORDER BY timecreated DESC, id ASC";
        if ($contacts = $DB->get_records_sql($sql, [$userid, $userid], $limitfrom, $limitnum)) {
            $userids = [];
            foreach ($contacts as $contact) {
                if ($contact->userid == $userid) {
                    $userids[] = $contact->contactid;
                } else {
                    $userids[] = $contact->userid;
                }
            }
            return helper::get_member_info($userid, $userids);
        }

        return [];
    }
1188172
public function setMaxResults($maxResults)
    {
        $this->_maxResults = $maxResults;
        $this->_state      = self::STATE_DIRTY;

        return $this;
    }
653604
public function search($q, $maxResults = 10, $part = ['id', 'snippet'])
    {
        $params = [
            'q' => $q,
            'part' => implode(', ', $part),
            'maxResults' => $maxResults,
        ];

        return $this->searchAdvanced($params);
    }
244283
public function find(string $uuid, int $max_version = null, int $min_version = null): array
    {
        return $this->findEventObjects(EventStreamObject::class, $uuid, $max_version, $min_version);
    }
672536
public static function data_for_messagearea_search_users($userid, $search, $limitnum = 0) {
        global $CFG, $PAGE, $USER;

        // Check if messaging is enabled.
        if (empty($CFG->messaging)) {
            throw new moodle_exception('disabled', 'message');
        }

        $systemcontext = context_system::instance();

        $params = array(
            'userid' => $userid,
            'search' => $search,
            'limitnum' => $limitnum
        );
        $params = self::validate_parameters(self::data_for_messagearea_search_users_parameters(), $params);
        self::validate_context($systemcontext);

        if (($USER->id != $params['userid']) && !has_capability('moodle/site:readallmessages', $systemcontext)) {
            throw new moodle_exception('You do not have permission to perform this action.');
        }

        list($contacts, $courses, $noncontacts) = \core_message\api::search_users(
            $params['userid'],
            $params['search'],
            $params['limitnum']
        );

        $search = new \core_message\output\messagearea\user_search_results($contacts, $courses, $noncontacts);

        $renderer = $PAGE->get_renderer('core_message');
        return $search->export_for_template($renderer);
    }
1308798
public function filaUnidade(Unidade $unidade)
    {
        $builder = $this->builder();
        
        $params = [
            'status'  => AtendimentoService::SENHA_EMITIDA,
            'unidade' => $unidade,
        ];
        
        $builder
            ->where('atendimento.status = :status')
            ->andWhere('atendimento.unidade = :unidade');
        
        $this->applyOrders($builder, $unidade);

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

        return $rs;
    }
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(),
        ]);
    }
1102876
private function getTipTransUnit($locale, $domain, $identifier)
    {
        $storage = $this->get('lexik_translation.translation_storage');
        try {
            // Note that getAllByLocaleAndDomain return arrays rather than entities; presumably for performance reasons
            $transUnits = $storage->getTransUnitsByLocaleAndDomain($locale, $domain);
        } catch (QueryException $e) {
            throw new \RuntimeException('Tips database not configured');
        }

        // Throw exception if not tips
        if (!$total = count($transUnits)) {
            throw new \RuntimeException('No tips in database');
        }

        // Get a random tip from the array
        $random = random_int(0, $total-1);

        // Now retrieve a single TransUnit entity
        $transUnitId = $transUnits[$random]['id'];
        $transUnit = $storage->getTransUnitById($transUnitId);

        // Retrieve meta data
        $om = $this->getObjectManager();
        $tipMetaDataRepository = $om->getRepository('TamagoTipsManagerBundle:TamagoTransUnitMeta');
        $tipMetaData = $tipMetaDataRepository->singleton($transUnit, $locale, $identifier);

        // Increment view count
        $tipMetaData->setViewCount($tipMetaData->getViewCount() + 1);
        $om->flush();

        return $transUnit;
    }
304167
public function chamarSenha(Unidade $unidade, Atendimento $atendimento)
    {
        $servico = $atendimento->getServico();
        
        $su = $this->storage
            ->getRepository(ServicoUnidade::class)
            ->get($unidade, $servico);
        
        $senha = new PainelSenha();
        $senha->setUnidade($unidade);
        $senha->setServico($servico);
        $senha->setNumeroSenha($atendimento->getSenha()->getNumero());
        $senha->setSiglaSenha($atendimento->getSenha()->getSigla());
        $senha->setMensagem($su->getMensagem() . '');
        // local
        $senha->setLocal($atendimento->getLocal()->getNome());
        $senha->setNumeroLocal($atendimento->getNumeroLocal());
        // prioridade
        $senha->setPeso($atendimento->getPrioridade()->getPeso());
        $senha->setPrioridade($atendimento->getPrioridade()->getNome());
        // cliente
        if ($atendimento->getCliente()) {
            $senha->setNomeCliente($atendimento->getCliente()->getNome());
            $senha->setDocumentoCliente($atendimento->getCliente()->getDocumento());
        }

        $this->dispatcher->createAndDispatch('panel.pre-call', [$atendimento, $senha], true);
        
        $om = $this->storage->getManager();
        $om->persist($senha);
        $om->flush();

        $this->dispatcher->createAndDispatch('panel.call', [$atendimento, $senha], true);
    }
630011
public function getDeliveryExecutionsByStatus($userUri, $status)
    {
        $query = $this->getQueryBuilder()
            ->select("*")
            ->from(self::TABLE_NAME)
            ->where(self::COLUMN_USER_ID . " = :userId")
            ->andWhere(self::COLUMN_STATUS . " = :status")
            ->setParameter("userId", $userUri)
            ->setParameter("status", $status)
        ;

        return array_map(function($row) {
            return $this->parseQueryResult($row);
        }, $query->execute()->fetchAll());
    }
446700
public function listUsers(int $maxResults = null, int $batchSize = null): \Generator
    {
        $maxResults = $maxResults ?? 1000;
        $batchSize = $batchSize ?? 1000;

        $pageToken = null;
        $count = 0;

        do {
            $response = $this->client->downloadAccount($batchSize, $pageToken);
            $result = JSON::decode((string) $response->getBody(), true);

            foreach ((array) ($result['users'] ?? []) as $userData) {
                yield UserRecord::fromResponseData($userData);

                if (++$count === $maxResults) {
                    return;
                }
            }

            $pageToken = $result['nextPageToken'] ?? null;
        } while ($pageToken);
    }
1022958
public function getLinkedDeliveryExecutions(core_kernel_classes_Resource $delivery, core_kernel_classes_Resource $link, $userId) {
        /** @var LtiDeliveryExecutionService $deliveryExecutionService */
	    $deliveryExecutionService = $this->getServiceLocator()->get(LtiDeliveryExecutionService::SERVICE_ID);
        $executions = $deliveryExecutionService->getLinkedDeliveryExecutions($delivery, $link, $userId);
        return $executions;
    }
921421
public function getTopKeywords($numberOfDays = 365, $maxResults = 30)
    {
        list($startDate, $endDate) = $this->calculateNumberOfDays($numberOfDays);

        return $this->getTopKeyWordsForPeriod($startDate, $endDate, $maxResults);
    }
910780
public function setMaxResults($maxResults)
    {
        $this->maxResults = $maxResults;
        $this->state      = self::STATE_DIRTY;

        return $this;
    }
110203
public function getUtils(): Utils
    {
        if ($this->_utils === null) {
            $this->_utils = new Utils($this->getSystemService());
        }

        return $this->_utils;
    }
445618
public function bloquearObjeto($numeroEtiqueta, $idPlp, $usuario, $senha)
    {
        $service = new ServiceImplementation\BloquearObjeto();
        return $service->execute($numeroEtiqueta, $idPlp, $usuario, $senha);
    }