Symfony Profiler

<?php
namespace App\Repository\Cliente\Dados;
use App\Entity\Cliente\Dados\Calculo;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\DBAL\Driver\ResultStatement;
use Doctrine\DBAL\ParameterType;
use Doctrine\Persistence\ManagerRegistry;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use App\Entity\Cliente\Modelagem\Modelagem;
use DateTime;
use Doctrine\DBAL\Result;
/**
* @method null|Calculo find($id, $lockMode = null, $lockVersion = null)
* @method null|Calculo findOneBy(array $criteria, array $orderBy = null)
* @method Calculo[] findAll()
* @method Calculo[] findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
*/
class CalculoRepository extends ServiceEntityRepository
{
/**
* @var SessionInterface
*/
private $session;
public function __construct(ManagerRegistry $registry, SessionInterface $session)
{
$this->session = $session;
parent::__construct($registry, Calculo::class);
}
/**
* @author Guilherme Arduino <guilherme.barlatti@2im.com.br>
*
* @return ResultStatement
*/
public function getDesempenhoIndicadores(array $programa, array $periodos, array $busca, string $gestor_permissoes = ''): ? ResultStatement
{
$sql = sprintf(
'SELECT
id_dominio
,nome_dominio
,md.ordem
,Jsonb_Agg(d) indicadores
FROM(
SELECT
id_indicador
,id_dominio
,nome_indicador
,nome_dominio
,total_indicador
,Jsonb_Agg(qtd_avaliados ORDER BY performance ASC) contagem
,Jsonb_Agg(performance ORDER BY performance ASC) performance
,Jsonb_Agg(porcentagem ORDER BY performance ASC) porcentagem
FROM(
SELECT
id_indicador
,nome_indicador
,id_dominio
,nome_dominio
,performance
,contagem
,total_indicador
,COUNT(DISTINCT id_avaliado) qtd_avaliados
,CASE WHEN total_indicador > 0 THEN ROUND((SUM(contagem) / SUM(total_indicador)) * 100, 2) ELSE 0 END porcentagem
FROM(
SELECT
id_avaliado
,id_indicador
,nome_indicador
,id_dominio
,nome_dominio
,performance
,COUNT(1) OVER(PARTITION BY id_indicador, performance) contagem
,COUNT(1) FILTER(WHERE id_avaliado IS NOT NULL) OVER(PARTITION BY id_indicador) total_indicador
FROM (
SELECT
mi.id_indicador
,mi.titulo nome_indicador
,md.id_dominio
,md.titulo nome_dominio
,id_programa
,i.id_avaliado
,ms.id_grupo
,performance
FROM
modelagem.scorecard ms
JOIN modelagem.indicador mi USING(id_indicador)
JOIN modelagem.dominio md USING(id_dominio)
JOIN modelagem.modelagem mm USING(id_modelagem)
LEFT JOIN (
SELECT
id_avaliado
,id_indicador
,ROUND(performance, 2) performance
,id_grupo
FROM
dados.calculo
WHERE TRUE
%s %s %s
) i USING(id_indicador, id_grupo)
WHERE TRUE %s %s
ORDER BY 1
) a
WHERE TRUE %s
) b
GROUP BY 1,2,3,4,5,6,7
ORDER BY 3,1,4
) c
GROUP BY 1,2,3,4,5
) d
JOIN modelagem.dominio md USING(id_dominio)
GROUP BY 1,2,3
ORDER BY 3',
$periodos['where'],
$programa['where'],
$busca[0] ?? '',
$programa['where'],
$busca[1] ?? '',
$gestor_permissoes
);
return $this->_em->getConnection()->executeQuery($sql);
}
/**
* @return ResultStatement
*/
public function getIndicadoresContagemPorDesempenho(array $programa, array $periodos, array $busca, string $gestor_permissoes = ''): ? ResultStatement
{
$sql = sprintf("SELECT
id_dominio,
nome_dominio,
Jsonb_Agg(e) indicadores
FROM (
SELECT
id_indicador,
id_dominio,
nome_indicador,
nome_dominio,
total_indicador,
Jsonb_Agg(contagem ORDER BY performance ASC) contagem,
Jsonb_Agg(performance ORDER BY performance ASC) performance,
Jsonb_Agg(porcentagem ORDER BY performance ASC) porcentagem
FROM (
SELECT
id_indicador,
id_dominio,
nome_indicador,
nome_dominio,
total_indicador,
contagem,
performance,
CASE
WHEN total_indicador > 0 THEN ROUND( (contagem::numeric * 100) / total_indicador::numeric, 3)
ELSE 0
END porcentagem
FROM (
SELECT
b.*,
COUNT(1) OVER(PARTITION BY id_indicador, performance) contagem,
COUNT(1) OVER(PARTITION BY id_indicador) total_indicador
FROM (
SELECT
a.*,
CASE
WHEN performance = 100 THEN 100.00
WHEN performance BETWEEN 90 AND 99.99 THEN 90.00
WHEN performance BETWEEN 80 AND 89.99 THEN 80.00
WHEN performance BETWEEN 70 AND 79.99 THEN 70.00
WHEN performance BETWEEN 60 AND 69.99 THEN 60.00
WHEN performance BETWEEN 50 AND 59.99 THEN 50.00
WHEN performance BETWEEN 40 AND 49.99 THEN 40.00
WHEN performance BETWEEN 30 AND 39.99 THEN 30.00
WHEN performance BETWEEN 20 AND 29.99 THEN 20.00
WHEN performance BETWEEN 10 AND 19.99 THEN 10.00
WHEN performance BETWEEN 0 AND 9.99 THEN 0.00
ELSE performance
END performance
FROM (
SELECT
DISTINCT id_avaliado,
nome_avaliado,
id_indicador,
nome_indicador,
id_dominio,
nome_dominio,
id_modelagem,
id_programa,
id_grupo,
periodo
FROM modelagem.scorecard_avaliados
JOIN LATERAL (
SELECT generate_periodo periodo FROM generate_periodo(%s,%s)
) p ON periodo BETWEEN avaliacao_inicio AND avaliacao_fim
JOIN (
SELECT DISTINCT id_avaliado FROM dados.calculo c WHERE Concat(c.periodo->>'ano', c.periodo->>'periodo')::integer BETWEEN %s AND %s AND id_programa = %s AND id_modelagem = %s
) av USING(id_avaliado)
WHERE TRUE
%s %s %s %s
) a
LEFT JOIN dados.calculo c ON a.id_avaliado = c.id_avaliado AND a.id_indicador = c.id_indicador AND a.periodo::text = Concat(c.periodo->>'ano', c.periodo->>'periodo') AND a.id_programa = c.id_programa AND a.id_modelagem = c.id_modelagem
WHERE TRUE AND c.id_modelagem = %s AND c.id_programa = %s
ORDER BY 1,3,5,9
) b
) c
GROUP BY 1,2,3,4,5,6,7
) d
GROUP BY 1,2,3,4,5
) e
GROUP BY 1,2
ORDER BY 1",
$periodos['from']['ano'] . $periodos['from']['periodo'],
$periodos['to']['ano'] . $periodos['to']['periodo'],
$periodos['from']['ano'] . $periodos['from']['periodo'],
$periodos['to']['ano'] . $periodos['to']['periodo'],
$programa['programa']['id_programa'],
$programa['modelagem'],
$busca[0] ?? '',
$programa['where'],
$busca[1] ?? '',
$gestor_permissoes,
$programa['modelagem'],
$programa['programa']['id_programa']
);
$sql = sprintf("SELECT
id_dominio,
nome_dominio,
Jsonb_Agg(e) indicadores
FROM (
SELECT
id_indicador,
id_dominio,
nome_indicador,
nome_dominio,
total_indicador,
Jsonb_Agg(contagem ORDER BY performance ASC) contagem,
Jsonb_Agg(performance ORDER BY performance ASC) performance,
Jsonb_Agg(porcentagem ORDER BY performance ASC) porcentagem
FROM (
SELECT
id_indicador,
id_dominio,
nome_indicador,
nome_dominio,
total_indicador,
performance_decil as performance,
COUNT(1)contagem,
CASE
WHEN total_indicador > 0 THEN ROUND( (COUNT(1)::numeric * 100) / total_indicador::numeric, 3)
ELSE 0
END porcentagem
FROM (
SELECT
b.*,
COUNT(1) OVER(PARTITION BY id_indicador) total_indicador
FROM (
SELECT
a.*,
CASE
WHEN ROUND(performance, 2) = 100 THEN 100.00
WHEN ROUND(performance, 2) BETWEEN 90 AND 99.99 THEN 90.00
WHEN ROUND(performance, 2) BETWEEN 80 AND 89.99 THEN 80.00
WHEN ROUND(performance, 2) BETWEEN 70 AND 79.99 THEN 70.00
WHEN ROUND(performance, 2) BETWEEN 60 AND 69.99 THEN 60.00
WHEN ROUND(performance, 2) BETWEEN 50 AND 59.99 THEN 50.00
WHEN ROUND(performance, 2) BETWEEN 40 AND 49.99 THEN 40.00
WHEN ROUND(performance, 2) BETWEEN 30 AND 39.99 THEN 30.00
WHEN ROUND(performance, 2) BETWEEN 20 AND 29.99 THEN 20.00
WHEN ROUND(performance, 2) BETWEEN 10 AND 19.99 THEN 10.00
WHEN ROUND(performance, 2) BETWEEN 0 AND 9.99 THEN 0.00
ELSE ROUND(performance, 2)
END performance_decil
FROM dados.calculo a
WHERE Concat(a.periodo->>'ano', a.periodo->>'periodo')::integer BETWEEN %s AND %s AND id_programa = %s AND id_modelagem = %s %s %s %s %s
) b
) c
GROUP BY 1,2,3,4,5,6
) d
GROUP BY 1,2,3,4,5
) e
GROUP BY 1,2
ORDER BY 1",
$periodos['from']['ano'] . $periodos['from']['periodo'],
$periodos['to']['ano'] . $periodos['to']['periodo'],
$programa['programa']['id_programa'],
$programa['modelagem'],
$busca[0] ?? '',
$programa['where'],
$busca[1] ?? '',
$gestor_permissoes
);
return $this->_em->getConnection()->executeQuery($sql);
}
/**
* @param string $ano
* @param integer $id_modelagem
* @param integer $id_grupo
* @param string $gestor_permissoes
* @return array
*/
public function getInformacaoIndicadores(string $ano, int $id_modelagem, int $id_grupo, string $gestor_permissoes = ''): array
{
$fnWhereGrupo = function($alias) use($id_grupo) {
return ( $id_grupo > 0 ) ? "AND {$alias}.id_grupo = {$id_grupo}" : '';
};
$periodos = "(periodo->>'ano') = :ano";
if(!is_int($ano)) {
$explodeAno = explode('-', $ano);
$periodos = "CONCAT(periodo->>'ano', periodo->>'periodo')::int BETWEEN " . $explodeAno[0] . " AND " . $explodeAno[1];
}
$sql = "
WITH _modelagem AS (
SELECT DISTINCT
ms.id_indicador
,mi.titulo nome_indicador
,mi.id_dominio
,md.titulo nome_dominio
,md.ordem
FROM
modelagem.scorecard ms
JOIN modelagem.indicador mi USING(id_indicador)
JOIN modelagem.dominio md USING(id_dominio)
WHERE
ms.id_modelagem = :id_modelagem
AND ".$explodeAno[0]." >= ms.inicio AND ".$explodeAno[1]." <= ms.fim
". $fnWhereGrupo('ms') ."
ORDER BY
md.ordem
), _calculo AS (
SELECT
m.id_dominio
,m.nome_dominio
,m.id_indicador
,m.nome_indicador
,m.ordem
,dc.qtde_calculos
,dc.media_valor
,dc.media_performance
,dc.periodo
,dc.mes
,dc.mes_txt
FROM _modelagem m LEFT JOIN (
SELECT DISTINCT ON(id_indicador, periodo)
dc.id_dominio
,dc.nome_dominio
,dc.id_indicador
,dc.nome_indicador
,Count(1) OVER w_ip qtde_calculos
,(Avg(dc.valor) OVER w_ip)::numeric(10,2) media_valor
,(Avg(dc.performance) OVER w_ip)::numeric(10,2) media_performance
,((dc.periodo->>'ano')||(dc.periodo->>'periodo'))::integer periodo
,(dc.periodo->>'periodo')::integer mes
,(ARRAY['jan','fev','mar','abr','mai','jun','jul','ago','set','out','nov','dez'])[(dc.periodo->>'periodo')::integer] mes_txt
FROM
dados.calculo dc
WHERE
CONCAT(dc.periodo->>'ano', dc.periodo->>'periodo')::int BETWEEN %s AND %s
AND dc.periodo->>'tipo' = 'mes'
AND dc.id_modelagem = :id_modelagem
". $fnWhereGrupo('dc') ."
WINDOW
w_ip AS(PARTITION BY id_indicador, periodo)
) dc USING(id_indicador, id_dominio)
), _resultado AS (
SELECT
c.*
,a.qtde_avaliados
,CASE WHEN a.qtde_avaliados::numeric > 0 THEN ((c.qtde_calculos::numeric / a.qtde_avaliados::numeric) * 100)::numeric(10,2) ELSE 0 END perc_calc
FROM
_calculo c
JOIN LATERAL (
SELECT
Count(1) qtde_avaliados
FROM
modelagem.avaliacao ma
JOIN modelagem.scorecard ms ON(
ms.id_grupo = ma.id_grupo
AND ms.id_indicador = c.id_indicador
AND ms.id_modelagem = :id_modelagem
". $fnWhereGrupo('ms') ."
)
WHERE
ma.id_modelagem = :id_modelagem
AND (c.periodo BETWEEN ma.inicio AND ma.fim)
AND (c.periodo BETWEEN ms.inicio AND ms.fim)
) a ON TRUE
ORDER BY
c.nome_dominio
,c.nome_indicador
)
SELECT
id_dominio
,nome_dominio
,id_indicador
,nome_indicador
,AVG(media_performance) media_media_performance
,jsonb_agg(qtde_calculos ORDER BY periodo) qtde_calculos
,jsonb_agg(media_valor ORDER BY periodo) media_valor
,jsonb_agg(media_performance ORDER BY periodo) media_performance
,jsonb_agg(qtde_avaliados ORDER BY periodo) qtde_avaliados
,jsonb_agg(perc_calc ORDER BY periodo) perc_calc
,jsonb_agg(mes_txt ORDER BY periodo) mes_txt
,jsonb_agg(mes ORDER BY periodo) mes
,jsonb_agg(periodo ORDER BY periodo) periodo
FROM
_resultado
WHERE TRUE {$gestor_permissoes}
GROUP BY
id_dominio
,nome_dominio
,id_indicador
,nome_indicador
";
$sql = sprintf($sql, explode('-', $ano)[0], explode('-', $ano)[1]);
$stmt = $this->_em->getConnection()->prepare($sql);
$stmt->bindValue(':id_modelagem', $id_modelagem, ParameterType::INTEGER);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function str_replace_first($search, $replace, $subject)
{
$search = '/'.preg_quote($search, '/').'/';
return preg_replace($search, $replace, $subject, 1);
}
/**
* Undocumented function
*
* @param integer $ano
* @param Modelagem $modelagem
* @param integer $id_grupo
* @param string $gestor_permissoes
* @return ResultStatement|null
*/
public function getInformacaoAvaliadosEvsProdcao($ano, Modelagem $modelagem, int $id_grupo, string $gestor_permissoes = '', bool $evs = true): ?ResultStatement
{
$tabela = 'evs';
$campo = 'valor';
$toChar = '0D99';
if (!$evs) {
$tabela = 'gps';
$campo = 'performance';
$toChar = '999D99%';
}
$andIdGrupo = NULL;
if ( $id_grupo > 0 ) {
$andIdGrupo = 'AND id_grupo = :id_grupo';
}
$periodos = "(periodo->>'ano') = :ano";
if(!is_int($ano)) {
$explodeAno = explode('-', $ano);
$periodos = "CONCAT(periodo->>'ano', periodo->>'periodo')::int BETWEEN " . $explodeAno[0] . " AND " . $explodeAno[1];
}
// prepare sql
$sql = "
WITH _{$tabela} AS (
SELECT
id_avaliado
,nome_avaliado
,id_grupo
,nome_grupo
,Concat(periodo->>'ano', periodo->>'periodo')::int periodo
,{$campo} {$tabela}
,Trim(To_Char({$campo}, '{$toChar}')) {$tabela}_txt
,Round(Avg({$campo}) OVER(PARTITION BY id_grupo, id_avaliado), 2) AS {$tabela}_anual
,Trim(To_Char(Round(Avg({$campo}) OVER(PARTITION BY id_grupo, id_avaliado), 2), '{$toChar}')) AS {$tabela}_anual_txt
FROM
dados.{$tabela}
WHERE
{$periodos}
AND id_modelagem = :id_modelagem
{$gestor_permissoes}
{$andIdGrupo}
)
SELECT DISTINCT
{$tabela}.*
,Substring({$tabela}.periodo::text,5,2)::integer periodo_mes
,To_Char((({$tabela}.periodo)::text||'01')::date,'MM')::int periodo_txt
FROM
_{$tabela} {$tabela}
ORDER BY
{$tabela}.{$tabela}_anual DESC
,{$tabela}.periodo
,{$tabela}.id_avaliado
";
$stmt = $this->_em->getConnection()->prepare($sql);
if(is_int($ano)) {
$stmt->bindValue(':ano', $ano, ParameterType::INTEGER);
}
$stmt->bindValue(':id_modelagem', $modelagem->getIdModelagem(), ParameterType::INTEGER);
if ( $id_grupo > 0 ) {
$stmt->bindValue(':id_grupo', $id_grupo, ParameterType::INTEGER);
}
return $stmt->executeQuery();
}
/**
* @param integer $ano
* @param Modelagem $modelagem
* @param integer $id_grupo
* @param string $gestor_permissoes
* @return Result|null
*/
public function getInformacaoEspecialidadesEvsProducao($ano, Modelagem $modelagem, int $id_grupo, string $gestor_permissoes = '', bool $evs = true): ?Result
{
$tabela = 'evs';
$campo = 'valor';
$toChar = '0D99';
if (!$evs) {
$tabela = 'gps';
$campo = 'performance';
$toChar = '999D99%';
}
$andIdGrupo = NULL;
if ( $id_grupo > 0 ) {
$andIdGrupo = 'AND id_grupo = :id_grupo';
}
$periodos = "(periodo->>'ano') = :ano";
if(!is_int($ano)) {
$explodeAno = explode('-', $ano);
$periodos = "CONCAT(periodo->>'ano', periodo->>'periodo')::int BETWEEN " . $explodeAno[0] . " AND " . $explodeAno[1];
}
// prepare sql
$sql = "WITH _{$tabela} AS (
SELECT id_grupo
,nome_grupo
,Concat(periodo->>'ano', periodo->>'periodo')::int periodo
,{$campo} {$tabela}
,Round(Avg({$campo}) OVER(PARTITION BY id_grupo), 2) AS {$tabela}_anual
,Trim(To_Char(Round(Avg({$campo}) OVER(PARTITION BY id_grupo), 2), '{$toChar}')) AS {$tabela}_anual_txt
FROM
dados.{$tabela}
WHERE
{$periodos}
AND id_modelagem = :id_modelagem
{$gestor_permissoes}
{$andIdGrupo}
)
SELECT
{$tabela}.id_grupo
, MAX({$tabela}.nome_grupo) AS nome_grupo
, ROUND(AVG({$tabela}.{$tabela}), 2) AS {$tabela}
, TRIM(To_Char(ROUND(AVG({$tabela}.{$tabela}), 2), '{$toChar}')) AS {$tabela}_media_txt
, ROUND(AVG({$tabela}.{$tabela}_anual), 2) AS {$tabela}_anual
, TRIM(TO_CHAR(ROUND(AVG({$tabela}.{$tabela}), 2), '{$toChar}')) AS {$tabela}_txt
, MAX({$tabela}_anual_txt) AS {$tabela}_anual_txt
, {$tabela}.periodo
, Substring({$tabela}.periodo::text, 5, 2)::integer periodo_mes
, To_Char((({$tabela}.periodo)::text || '01')::date, 'MM')::int periodo_txt
FROM
_{$tabela} {$tabela}
GROUP BY
{$tabela}.id_grupo, periodo
ORDER BY
{$tabela} DESC,
{$tabela}.id_grupo,
{$tabela}.periodo
";
$stmt = $this->_em->getConnection()->prepare($sql);
if(is_int($ano)) {
$stmt->bindValue(':ano', $ano, ParameterType::INTEGER);
}
$stmt->bindValue(':id_modelagem', $modelagem->getIdModelagem(), ParameterType::INTEGER);
if ( $id_grupo > 0 ) {
$stmt->bindValue(':id_grupo', $id_grupo, ParameterType::INTEGER);
}
return $stmt->executeQuery();
}
/**
* Undocumented function
*
* @param integer $ano
* @param Modelagem $modelagem
* @param integer $id_grupo
* @param string $gestor_permissoes
* @return ResultStatement|null
*/
public function getInformacaoAvaliadosEvsProducaoRede($ano, Modelagem $modelagem, int $id_grupo, string $gestor_permissoes = '', bool $evs = true): ?ResultStatement
{
$tabela = 'evs';
$campo = 'valor';
$toChar = '0D99';
if (!$evs) {
$tabela = 'gps';
$campo = 'performance';
$toChar = '999D99%';
}
$modelagemConfig = $modelagem->getConfig() ?? [];
// sem regra configurada para producao
if ( !array_key_exists('producao', $modelagemConfig) ) {
return NULL;
}
// array de producao
$jsonProducao = $modelagemConfig['producao'];
$queryOrTabelaProducao = array_filter($jsonProducao, function($value, $key) {
return (in_array($key, ['query','tabela']) AND strlen($value) > 5);
},ARRAY_FILTER_USE_BOTH);
// sem campos configurados
if ( count($queryOrTabelaProducao) === 0 ) {
return NULL;
}
if ( array_key_exists('tabela', $queryOrTabelaProducao) ) {
$columnIdAvaliado = ('layout_drg_2im_out' === $queryOrTabelaProducao['tabela']) ? 'cod_crm id_avaliado' : 'id_avaliado';
$queryOrTabelaProducao = "SELECT DISTINCT {$columnIdAvaliado} FROM robot.{$queryOrTabelaProducao['tabela']} WHERE periodo = :periodo";
} else {
$queryOrTabelaProducao = $queryOrTabelaProducao['query'];
if(strstr($queryOrTabelaProducao, 'layout_drg_2im_out')) {
$queryOrTabelaProducao = $this->str_replace_first('cod_crm','cod_crm id_avaliado',$queryOrTabelaProducao);
}
}
// replece bind
$queryOrTabelaProducao = str_replace(['{%PERIODO%}',':periodo'],"{$tabela}.periodo", $queryOrTabelaProducao);
$andIdGrupo = NULL;
if ( $id_grupo > 0 ) {
$andIdGrupo = 'AND id_grupo = :id_grupo';
}
$periodos = "(periodo->>'ano') = :ano";
if(!is_int($ano)) {
$explodeAno = explode('-', $ano);
$periodos = "CONCAT(periodo->>'ano', periodo->>'periodo')::int BETWEEN " . $explodeAno[0] . " AND " . $explodeAno[1];
}
// prepare sql
$sql = "
WITH _{$tabela} AS (
SELECT
id_avaliado
,nome_avaliado
,id_grupo
,nome_grupo
,id_modelagem
, nome_modelagem
,Concat(periodo->>'ano', periodo->>'periodo')::int periodo
,{$campo} {$tabela}
,Trim(To_Char({$campo}, '{$toChar}')) {$tabela}_txt
,Round(Avg({$campo}) OVER(PARTITION BY id_modelagem, id_grupo, id_avaliado), 2) AS {$tabela}_anual
,Trim(To_Char(Round(Avg({$campo}) OVER(PARTITION BY id_modelagem, id_grupo, id_avaliado), 2), '{$toChar}')) AS {$tabela}_anual_txt
FROM
dados.{$tabela}
WHERE
{$periodos}
{$gestor_permissoes}
{$andIdGrupo}
)
SELECT DISTINCT
{$tabela}.*
,prod.id_avaliado IS NOT NULL is_producao
,Substring({$tabela}.periodo::text,5,2)::integer periodo_mes
,To_Char((({$tabela}.periodo)::text||'01')::date,'MM')::int periodo_txt
FROM
_{$tabela} {$tabela}
LEFT JOIN LATERAL (
{$queryOrTabelaProducao}
) prod USING(id_avaliado)
ORDER BY
{$tabela}.{$tabela}_anual DESC
,{$tabela}.periodo
,{$tabela}.id_avaliado
";
$stmt = $this->_em->getConnection()->prepare($sql);
if(is_int($ano)) {
$stmt->bindValue(':ano', $ano, ParameterType::INTEGER);
}
if ( $id_grupo > 0 ) {
$stmt->bindValue(':id_grupo', $id_grupo, ParameterType::INTEGER);
}
if (strstr($queryOrTabelaProducao, ':id_modelagem_rule') != false) {
$stmt->bindValue(':id_modelagem_rule', $modelagem->getIdModelagem(), ParameterType::INTEGER);
}
return $stmt->executeQuery();
}
/**
* @param array $programa
* @param array $periodos
* @param integer $id_indicador
* @param float $performance
* @param array $filtro
* @return array
*/
public function getDetalhesDistribuicaoDesempenho(array $programa, array $periodos, int $id_indicador, float $performance, array $filtro) :array
{
if ( count($filtro) > 0 ) {
$filtro = $filtro[0];
$campoBandas = ',dados bandas';
} else {
$filtro = '';
$campoBandas = '';
}
$sql = "
SELECT
*
,Sum(qtde_ocorrencia) OVER(ORDER BY qtde_ocorrencia DESC ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) rank
,Sum(qtde_ocorrencia) OVER() total
FROM (
SELECT DISTINCT ON(id_avaliado)
id_avaliado
,nome_avaliado
,id_indicador
,nome_indicador
,First_Value(nome_grupo) OVER(PARTITION BY id_avaliado) nome_grupo
,ROUND(performance, 2) performance
,COUNT(1) OVER(PARTITION BY id_avaliado) qtde_ocorrencia
{$campoBandas}
,Array_To_String(Array_Agg(Concat(periodo->>'periodo','/',periodo->>'ano')) OVER(PARTITION BY id_avaliado),',') referencias
FROM
dados.calculo
WHERE TRUE
{$periodos['where']}
{$programa['where']}
AND id_indicador = :id_indicador
AND ROUND(performance, 2) = :performance
{$filtro}
) a
ORDER BY
qtde_ocorrencia DESC
";
$stmt = $this->_em->getConnection()->prepare($sql);
$stmt->bindValue(':id_indicador', $id_indicador, ParameterType::INTEGER);
$stmt->bindValue(':performance', $performance, ParameterType::INTEGER);
return $stmt->executeQuery()->fetchAllAssociative();
}
/**
* @return array
*/
public function getDetalhesDesempenhoIndicador(int $id_indicador, array $periodos, array $filtros, array $programa, int $faixa)
{
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$whereFaixa = '';
$wherePerformance = '';
if ( $faixa >= 0 && $faixa <= 100 ) {
$whereFaixa = "AND performance BETWEEN {$faixa} AND {$faixa}+9.99";
} else if ($faixa == -1) {
$wherePerformance = "WHERE performance_0 > 0";
}
$sql = "SELECT * FROM (
SELECT
id_avaliado
, nome_avaliado
, id_indicador
,Concat(id_indicador, ' - ', nome_indicador) indicador
,unidade_indicador
,nome_grupo
,avaliado_media_performance
, COUNT(1) FILTER(WHERE performance IS NULL) performance_0
, COUNT(1) FILTER(WHERE performance IS NOT NULL) performance_1
, jsonb_object_agg(periodo, performance) performances
, jsonb_object_agg(periodo, valor) valores_absolutos
, jsonb_object_agg(periodo, numerador) numerador
, jsonb_object_agg(periodo, denominador) denominador
FROM (
SELECT
a.*
, periodo
, ROUND(b.performance, 2) performance
, ROUND(b.valor, 2) valor
,ROUND(Avg(performance) OVER(PARTITION BY a.id_avaliado), 2) avaliado_media_performance
, ROUND(b.numerador, 2) numerador
, ROUND(b.denominador, 2) denominador
FROM generate_periodo(%s, %s) AS periodo
JOIN LATERAL (
SELECT distinct id_avaliado, nome_avaliado, id_indicador, nome_indicador, First_Value(nome_grupo) OVER(PARTITION BY id_avaliado) nome_grupo, unidade_indicador
FROM dados.calculo
WHERE TRUE
{$programa['where']}
{$periodos['where']}
AND id_indicador = {$id_indicador}
{$whereFaixa}
{$whereFiltro}
) a ON TRUE
LEFT JOIN (
SELECT
id_avaliado
, nome_avaliado
, CONCAT(periodo->>'ano',periodo->>'periodo')::int AS periodo
, performance
, valor
, numerador
, denominador
FROM dados.calculo
WHERE TRUE
{$programa['where']}
{$periodos['where']}
AND id_indicador = {$id_indicador}
) b USING(id_avaliado, nome_avaliado, periodo)
) c
GROUP BY 1,2,id_indicador,nome_indicador, 4,5,6,7
ORDER BY 5 DESC, 1
) d
{$wherePerformance}";
$sql = sprintf($sql,
$periodos['from']['ano'] . $periodos['from']['periodo'],
$periodos['to']['ano'] . $periodos['to']['periodo']);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
/**
* @return array
*/
public function getDetalhesDesempenhoIndicadorNovoCalculoFaixa(int $id_indicador, array $periodos, array $filtros, array $programa, int $faixa)
{
//adicionando alias nessas colunas para otimização da query
$periodos['where'] = str_replace('periodo->>', 'dc.periodo->>', $periodos['where']);
$programa['where'] = str_replace('id_programa', 'dc.id_programa', $programa['where']);
$programa['where'] = str_replace('id_modelagem', 'dc.id_modelagem', $programa['where']);
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$whereFaixa = '';
$wherePerformance = '';
if ( $faixa >= 0 && $faixa <= 100 ) {
$whereFaixa = "AND performance BETWEEN {$faixa} AND {$faixa}+9.99";
} else if ($faixa == -1) {
$wherePerformance = "WHERE performance_0 > 0";
}
$sql = "SELECT * FROM (
SELECT
id_avaliado
, nome_avaliado
, id_indicador
, Concat(id_indicador, ' - ', nome_indicador) indicador
, unidade_indicador
, nome_grupo
, risco
, avaliado_media_performance
, jsonb_object_agg(periodo, jsonb_build_object(
'risco', risco,
'performance_risco', performance_risco,
'performance', performance,
'numerador', numerador,
'denominador', denominador,
'valor', valor
)
) AS resultado
, COUNT(1) FILTER(WHERE performance IS NULL) performance_0
, COUNT(1) FILTER(WHERE performance IS NOT NULL) performance_1
, jsonb_object_agg(periodo, performance) performances
FROM (
SELECT
b.cod_ajuste AS risco
, a.*
, periodo
, ROUND(b.performance, 2) performance
, ROUND(b.valor, 2) valor
, ROUND(AVG(performance) OVER(PARTITION BY a.id_avaliado), 2) avaliado_media_performance
, performance_risco
, ROUND(b.numerador, 2) numerador
, ROUND(b.denominador, 2) denominador
FROM generate_periodo(%s, %s) AS periodo
JOIN LATERAL (
SELECT
DISTINCT dc.id_avaliado,
dc.nome_avaliado,
dc.id_indicador,
dc.nome_indicador,
FIRST_VALUE(dc.nome_grupo) OVER(PARTITION BY dc.id_avaliado) nome_grupo,
dc.unidade_indicador
FROM dados.novo_calculo dn
LEFT JOIN dados.calculo dc USING(id_avaliado, id_indicador, id_modelagem, id_programa, periodo)
WHERE TRUE
{$programa['where']}
{$periodos['where']}
AND dc.id_indicador = {$id_indicador}
{$whereFaixa}
".str_replace('id_grupo', 'dn.id_grupo',$whereFiltro)."
) a ON TRUE
LEFT JOIN (
SELECT
(dn.detalhes->'data'->0->>'cod_ajuste')::numeric AS cod_ajuste
, dc.id_avaliado
, dc.nome_avaliado
, CONCAT(dc.periodo->>'ano', dc.periodo->>'periodo')::int AS periodo
, dc.performance
, dc.valor
, (dn.detalhes->'data'->0->>'resultado')::numeric AS performance_risco
, (dn.detalhes->'data'->0->>'numerador')::numeric AS numerador
, (dn.detalhes->'data'->0->>'denominador')::numeric AS denominador
FROM dados.novo_calculo dn
LEFT JOIN dados.calculo dc USING(id_avaliado, id_indicador, id_modelagem, id_programa, periodo)
WHERE TRUE
{$programa['where']}
{$periodos['where']}
AND dc.id_indicador = {$id_indicador}
ORDER BY 2,4,1
) b USING(id_avaliado, nome_avaliado, periodo)
) e
GROUP BY 1,2,id_indicador,nome_indicador,4,5,6,risco,7,8
ORDER BY 5 DESC, 1
) d
{$wherePerformance}";
$sql = sprintf($sql,
$periodos['from']['ano'] . $periodos['from']['periodo'],
$periodos['to']['ano'] . $periodos['to']['periodo']);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function getDetalhesDesempenhoIndicadorDistribuicao(int $id_indicador, string $periodo, array $filtros, array $programa)
{
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$sql = "SELECT * FROM (
SELECT
id_avaliado
, nome_avaliado
, id_indicador
,Concat(id_indicador, ' - ', nome_indicador) indicador
,unidade_indicador
,nome_grupo
,avaliado_media_performance
, COUNT(1) FILTER(WHERE performance IS NULL) performance_0
, COUNT(1) FILTER(WHERE performance IS NOT NULL) performance_1
, jsonb_object_agg(periodo, performance) performances
, jsonb_object_agg(periodo, valor) valores_absolutos
, jsonb_object_agg(periodo, numerador) numerador
, jsonb_object_agg(periodo, denominador) denominador
FROM (
SELECT
a.*
, periodo
, ROUND(b.performance, 2) performance
, ROUND(b.valor, 2) valor
,ROUND(Avg(performance) OVER(PARTITION BY a.id_avaliado), 2) avaliado_media_performance
, ROUND(b.numerador, 2) numerador
, ROUND(b.denominador, 2) denominador
FROM generate_periodo(%s, %s) AS periodo
JOIN LATERAL (
SELECT distinct id_avaliado, nome_avaliado, id_indicador, nome_indicador, First_Value(nome_grupo) OVER(PARTITION BY id_avaliado) nome_grupo, unidade_indicador
FROM dados.calculo
WHERE TRUE
{$programa['where']}
AND CONCAT(periodo->>'ano', LPAD(periodo->>'periodo', 2, '0'))::int = {$periodo}
AND id_indicador = {$id_indicador}
{$whereFiltro}
) a ON TRUE
LEFT JOIN (
SELECT
id_avaliado
, nome_avaliado
, CONCAT(periodo->>'ano',periodo->>'periodo')::int AS periodo
, performance
, valor
, numerador
, denominador
FROM dados.calculo
WHERE TRUE
{$programa['where']}
AND CONCAT(periodo->>'ano', LPAD(periodo->>'periodo', 2, '0'))::int = {$periodo}
AND id_indicador = {$id_indicador}
) b USING(id_avaliado, nome_avaliado, periodo)
) c
GROUP BY 1,2,id_indicador,nome_indicador, 4,5,6,7
ORDER BY 5 DESC, 1
) d";
$sql = sprintf($sql, $periodo, $periodo);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function getDetalhesDesempenhoIndicadorNovoCalculo(int $id_indicador, string $periodo, array $filtros, array $programa)
{
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$sql = "SELECT * FROM (
SELECT
id_avaliado
, nome_avaliado
, id_indicador
, Concat(id_indicador, ' - ', nome_indicador) indicador
, unidade_indicador
, nome_grupo
, risco
, avaliado_media_performance
, performance_risco
, COUNT(1) FILTER(WHERE performance IS NULL) performance_0
, COUNT(1) FILTER(WHERE performance IS NOT NULL) performance_1
, jsonb_object_agg(periodo, performance) performances
, jsonb_object_agg(periodo, valor) valores_absolutos
, jsonb_object_agg(periodo, numerador) numerador
, jsonb_object_agg(periodo, denominador) denominador
FROM (
SELECT
b.cod_ajuste AS risco
, a.*
, periodo
, ROUND(b.performance, 2) performance
, ROUND(b.valor, 2) valor
, ROUND(AVG(performance) OVER(PARTITION BY a.id_avaliado), 2) avaliado_media_performance
, performance_risco
, ROUND(b.numerador, 2) numerador
, ROUND(b.denominador, 2) denominador
FROM generate_periodo(%s, %s) AS periodo
JOIN LATERAL (
SELECT
DISTINCT dc.id_avaliado,
dc.nome_avaliado,
dc.id_indicador,
dc.nome_indicador,
FIRST_VALUE(dc.nome_grupo) OVER(PARTITION BY dc.id_avaliado) nome_grupo,
dc.unidade_indicador
FROM dados.novo_calculo dn
JOIN dados.calculo dc USING(id_avaliado, id_indicador, id_modelagem, id_programa, periodo, id_grupo)
WHERE TRUE
{$programa['where']}
AND CONCAT(periodo->>'ano', LPAD(periodo->>'periodo', 2, '0'))::int = {$periodo}
AND id_indicador = {$id_indicador}
{$whereFiltro}
) a ON TRUE
LEFT JOIN (
SELECT
(dn.detalhes->'data'->0->>'cod_ajuste')::numeric AS cod_ajuste
, dc.id_avaliado
, dc.nome_avaliado
, CONCAT(dc.periodo->>'ano', dc.periodo->>'periodo')::int AS periodo
, dc.performance
, dc.valor
, (dn.detalhes->'data'->0->>'resultado')::numeric AS performance_risco
, (dn.detalhes->'data'->0->>'numerador')::numeric AS numerador
, (dn.detalhes->'data'->0->>'denominador')::numeric AS denominador
FROM dados.novo_calculo dn
JOIN dados.calculo dc USING(id_avaliado, id_indicador, id_modelagem, id_programa, periodo, id_grupo)
WHERE TRUE
{$programa['where']}
AND CONCAT(periodo->>'ano', LPAD(periodo->>'periodo', 2, '0'))::int = {$periodo}
AND id_indicador = {$id_indicador}
ORDER BY 2,1
) b USING(id_avaliado, nome_avaliado, periodo)
) c
GROUP BY 1,2,id_indicador,nome_indicador,4,5,6,risco,7,8,9
ORDER BY 5 DESC, 1
) d";
$sql = sprintf($sql, $periodo, $periodo);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function checkIfHasBancoNovoCalculo($id_indicador)
{
$sql = "SELECT EXISTS(
SELECT
FROM information_schema.tables
WHERE table_schema = 'dados' AND table_name = 'novo_calculo'
)
";
if($this->_em->getConnection()->executeQuery($sql)->fetchOne()) {
if($this->_em->getConnection()->executeQuery(
"SELECT count(1) FROM dados.novo_calculo WHERE id_indicador = {$id_indicador}"
)->fetchOne() > 0){
return true;
}
}
return false;
}
/**
* Faz um count distinto da quantidade de Avaliados, Indicadores, Grupos e, caso o $programa venha sem 'id_modelagem', Modelagens
* da tabela dados.calculo para ser utilizado nos alertas da visão Gestor e Gestor de Rede
*/
public function findQtdsAlertasGestor(array $periodos, array $filtros, array $programa, ?string $gestor_permissoes = null)
{
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$countModelagens = '';
if (strstr($programa['where'], 'id_modelagem') == false) {
$countModelagens = 'COUNT(DISTINCT id_modelagem) qtd_modelagens,';
}
$sql = "SELECT
{$countModelagens}
COUNT(DISTINCT id_avaliado) qtd_avaliados,
COUNT(DISTINCT id_indicador) qtd_indicadores,
COUNT(DISTINCT id_grupo) qtd_grupos
FROM
dados.calculo c
WHERE CONCAT(periodo->>'ano',periodo->>'periodo')::int BETWEEN ".$periodos['from']['ano'].$periodos['from']['periodo']." AND ".$periodos['to']['ano'].$periodos['to']['periodo']."
{$programa['where']}
{$whereFiltro}
{$gestor_permissoes}";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAssociative();
}
/**
* Faz um count distinto da quantidade total de Avaliados, Indicadores, Grupos e, caso o $programa venha sem 'id_modelagem', Modelagens
* da tabela modelagem.scorecard_avaliados para ser utilizado nos alertas da visão Gestor e Gestor de Rede
*/
public function findTotaisAlertasGestor(array $periodos, array $filtros, array $programa)
{
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$totalModelagens = '';
if (strstr($programa['where'], 'id_modelagem') == false) {
$totalModelagens = 'COUNT(DISTINCT id_modelagem) total_modelagens,';
}
$sql = "SELECT
{$totalModelagens}
COUNT(DISTINCT id_avaliado) total_avaliados,
COUNT(DISTINCT id_indicador) total_indicadores,
COUNT(DISTINCT id_grupo) total_grupos
FROM
modelagem.scorecard_avaliados
JOIN LATERAL (
SELECT generate_periodo periodo FROM generate_periodo(%s,%s)
) p ON p.periodo BETWEEN avaliacao_inicio AND avaliacao_fim AND p.periodo BETWEEN scorecard_inicio AND scorecard_fim
WHERE TRUE
{$programa['where']}
{$whereFiltro}";
$sql = sprintf($sql, $periodos['from']['ano'] . $periodos['from']['periodo'], $periodos['to']['ano'] . $periodos['to']['periodo']);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAssociative();
}
/**
* Faz um count da quantidade de avaliados que estão abaixo da nota de corte setada na sessão
*/
public function findQtdAvaliadosAbaixoNotaCorte(array $periodos, array $filtros, array $programa, ?string $gestor_permissoes = null)
{
$notaCorte = $this->session->get('nota_corte');
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$sql = "SELECT
COUNT(id_avaliado) abaixo_avaliados
FROM (
SELECT
id_avaliado,
AVG(%s) %s
FROM dados.%s
WHERE TRUE
{$periodos['where']}
{$programa['where']}
{$whereFiltro}
{$gestor_permissoes}
GROUP BY 1
) a
WHERE TRUE
%s";
$sql = sprintf($sql, $notaCorte['campo'], $notaCorte['campo'], $notaCorte['tabela'], $notaCorte['where']['abaixo']);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchOne();
}
/**
* Faz um count da quantidade de avaliados que estão abaixo da nota de corte setada na sessão
*/
public function findQtdGruposAbaixoNotaCorte(array $periodos, array $filtroSemAvaliado, array $programa, ?string $gestor_permissoes = null)
{
$notaCorte = $this->session->get('nota_corte');
$sql = "SELECT
COUNT(id_grupo) abaixo_grupos
FROM (
SELECT
id_grupo,
AVG(%s) %s
FROM dados.%s
WHERE TRUE
{$periodos['where']}
{$programa['where']}
%s
{$gestor_permissoes}
GROUP BY 1
) a
WHERE TRUE
%s";
$sql = sprintf($sql, $notaCorte['campo'], $notaCorte['campo'], $notaCorte['tabela'], $filtroSemAvaliado[0] ?? '', $notaCorte['where']['abaixo']);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchOne();
}
public function findQtdModelagensAbaixoNotaCorte(array $periodos, array $programa)
{
$notaCorte = $this->session->get('nota_corte');
$sql = "SELECT
COUNT(id_modelagem) abaixo_modelagens
FROM (
SELECT
id_modelagem,
AVG(%s) %s
FROM dados.%s
WHERE TRUE
{$periodos['where']}
{$programa['where']}
GROUP BY 1
) a
WHERE TRUE
%s";
$sql = sprintf($sql, $notaCorte['campo'], $notaCorte['campo'], $notaCorte['tabela'], $notaCorte['where']['abaixo']);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchOne();
}
/**
* @deprecated Ver TIDEV-68
* @return array
*/
public function findQtdAvaliadosGruposIndicadores(array $periodos, array $filtros, array $programa, array $filtroSemAvaliado)
{
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$notaCorte = $this->session->get('nota_corte');
$countModelagens = '';
$totalModelagens = '';
$abaixoModelagens = '';
$groupBy = 'id_modelagem';
if (strstr($programa['where'], 'id_modelagem') == false) {
$countModelagens = 'COUNT(DISTINCT id_modelagem) qtd_modelagens,';
$totalModelagens = 'COUNT(DISTINCT id_modelagem) total_modelagens,';
$abaixoModelagens = "JOIN LATERAL (
SELECT
COUNT(id_modelagem) abaixo_modelagens
FROM (
SELECT
id_modelagem,
AVG(performance) performance
FROM dados.gps
WHERE TRUE
{$periodos['where']}
{$programa['where']}
GROUP BY 1
) a
WHERE TRUE
{$notaCorte['where']['abaixo']}
) am ON TRUE";
$groupBy = 'id_programa';
}
$sql = sprintf("SELECT
*
FROM (
SELECT
{$countModelagens}
COUNT(DISTINCT id_avaliado) qtd_avaliados,
COUNT(DISTINCT id_indicador) qtd_indicadores,
COUNT(DISTINCT id_grupo) qtd_grupos
FROM
dados.calculo c
WHERE TRUE
{$periodos['where']}
{$programa['where']}
{$whereFiltro}
GROUP BY
$groupBy
) a
JOIN LATERAL (
SELECT
{$totalModelagens}
COUNT(DISTINCT id_avaliado) total_avaliados,
COUNT(DISTINCT id_indicador) total_indicadores,
COUNT(DISTINCT id_grupo) total_grupos
FROM
modelagem.scorecard_avaliados
JOIN LATERAL (
SELECT generate_periodo periodo FROM generate_periodo(%s,%s)
) p ON periodo BETWEEN avaliacao_inicio AND avaliacao_fim
WHERE TRUE
{$programa['where']}
{$whereFiltro}
) b ON TRUE
JOIN LATERAL (
SELECT
COUNT(id_avaliado) abaixo_avaliados
FROM (
SELECT
id_avaliado,
AVG(%s) %s
FROM dados.%s
WHERE TRUE
{$periodos['where']}
{$programa['where']}
{$whereFiltro}
GROUP BY 1
) a
WHERE TRUE
%s
) aa ON TRUE
JOIN LATERAL (
SELECT
COUNT(id_grupo) abaixo_grupos
FROM (
SELECT
id_grupo,
AVG(%s) %s
FROM dados.%s
WHERE TRUE
{$periodos['where']}
{$programa['where']}
%s
GROUP BY 1
) a
WHERE TRUE
%s
) ag ON TRUE
$abaixoModelagens
",
$periodos['from']['ano'] . $periodos['from']['periodo'],
$periodos['to']['ano'] . $periodos['to']['periodo'],
$notaCorte['campo'],
$notaCorte['campo'],
$notaCorte['tabela'],
$notaCorte['where']['abaixo'],
$notaCorte['campo'],
$notaCorte['campo'],
$notaCorte['tabela'],
$filtroSemAvaliado[0] ?? '',
$notaCorte['where']['abaixo']
);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function getCorrelacaoIndicadores(int $id_modelagem, int $id_grupo, int $periodo): array
{
$sql = "SELECT
indicador_1 AS indicador,
nome_indicador_1 AS nome_indicador,
jsonb_agg(correlacao) correlacoes
FROM (
SELECT
id_modelagem,
id_grupo,
indicador_1,
nome_indicador_1,
indicador_2,
nome_indicador_2,
corr(performance_1, performance_2) correlacao
FROM (
SELECT
id_modelagem,
id_grupo,
id_avaliado,
a.id_indicador AS indicador_1,
a.nome_indicador AS nome_indicador_1,
a.performance AS performance_1,
d.id_indicador AS indicador_2,
d.performance AS performance_2,
a.nome_indicador AS nome_indicador_2
FROM (
SELECT
id_modelagem,
id_grupo,
id_avaliado,
id_indicador,
nome_indicador,
AVG(performance) performance
FROM dados.calculo
WHERE id_modelagem = {$id_modelagem} AND id_grupo = {$id_grupo}
AND CONCAT(periodo->>'ano', periodo->>'periodo')::integer = {$periodo}
GROUP BY 1,2,3,4,5
) a
JOIN LATERAL(
SELECT
id_indicador,
nome_indicador,
AVG(performance) performance
FROM dados.calculo c
WHERE c.id_modelagem = a.id_modelagem AND c.id_grupo = a.id_grupo AND c.id_avaliado = a.id_avaliado
AND CONCAT(periodo->>'ano', periodo->>'periodo')::integer = {$periodo}
GROUP BY id_modelagem, id_grupo, id_avaliado, 1,2
) d ON true
ORDER BY 1,2,3,4,7
) b
GROUP BY 1,2,3,4,5,6
) c
GROUP BY 1,2";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
/**
* @param array|null $filtro
* @return array
*/
public function findCalculos(?array $filtro, ?bool $count = false, ?int $limit = null, ?int $offset = null)
{
$alias = !is_null($filtro['sem_resultado']) ? 'a.' : 'b.';
$arrayFiltro = [
'id_modelagem' => " AND b.id_modelagem IN (%s)",
'id_grupo' => " AND b.id_grupo IN (%s)",
'id_avaliado' => " AND b.id_avaliado IN (%s)"
];
$now = new DateTime('America/Sao_Paulo');
$filtro['data_inicio'] = !empty($filtro['data_inicio']) ? str_replace("/", "", $filtro['data_inicio']) : 199001;
$filtro['data_fim'] = !empty($filtro['data_fim']) ? str_replace("/", "", $filtro['data_fim']) : $now->format('Ym');
$sql = '';
$sql .= "SELECT
{$alias}id_programa
, {$alias}nome_programa
, {$alias}id_modelagem
, {$alias}nome_modelagem
, {$alias}id_dominio
, {$alias}nome_dominio
, {$alias}id_grupo
, {$alias}nome_grupo
, {$alias}id_avaliado
, {$alias}nome_avaliado
, {$alias}id_indicador
, {$alias}nome_indicador
, {$alias}unidade_indicador AS unidade
, dados
, REPLACE(numerador::text, '.', ',') AS numerador
, REPLACE(denominador::text, '.', ',') AS denominador
, REPLACE(valor::text, '.', ',') AS resultado
, REPLACE({$alias}peso::text, '.', ',') AS peso
, REPLACE(COALESCE(score, 0)::text, '.', ',') AS score
, periodo.periodo
FROM generate_periodo(:data_inicio, :data_fim) periodo";
if (!is_null($filtro['sem_resultado'])) {
$sql .= "\nJOIN LATERAL (
SELECT
DISTINCT id_programa
, nome_programa
, id_modelagem
, nome_modelagem
, id_dominio
, nome_dominio
, id_grupo
, nome_grupo
, id_avaliado
, nome_avaliado
, id_indicador
, nome_indicador
, unidade_indicador
, peso
FROM modelagem.scorecard_avaliados
WHERE avaliacao_fim BETWEEN :data_inicio and :data_fim %s
) a ON TRUE";
}
$sql .= "\nLEFT JOIN dados.calculo b ON
CONCAT(b.periodo->>'ano',b.periodo->>'periodo') = periodo.periodo::text
%s";
$where = '';
if (!is_null($filtro)) {
foreach ($filtro as $key => $content) {
if ( !empty($content) && in_array($key, array_keys($arrayFiltro))) {
if (is_array($content)) {
$filtro[$key] = implode(', ', $content);
}
$where .= sprintf($arrayFiltro[$key], $filtro[$key]);
}
}
}
if ( !is_null($filtro['sem_resultado']) ) {
$sql .= "\nAND a.id_programa = b.id_programa
AND a.id_modelagem = b.id_modelagem
AND a.id_dominio = b.id_dominio
AND a.id_grupo = b.id_grupo
AND a.id_avaliado = b.id_avaliado
AND a.id_indicador = b.id_indicador";
}
if ( !is_null($filtro['sem_resultado']) ) {
$sql = sprintf($sql, str_replace('b.', '', $where), $where);
} else {
$sql = sprintf($sql, $where);
}
$sql .= "\nORDER BY {$alias}id_avaliado, periodo, dados NULLS LAST
%s";
$sql = sprintf($sql, (!is_null($limit) ? "LIMIT $limit OFFSET $offset" : ''));
if ( $count ) {
$sql = sprintf("SELECT COUNT(*) AS rows FROM (%s) c", $sql);
}
$stmt = $this->_em->getConnection()->prepare($sql);
$stmt->bindParam(':data_inicio', $filtro['data_inicio'], ParameterType::INTEGER);
$stmt->bindParam(':data_fim', $filtro['data_fim'], ParameterType::INTEGER);
return $stmt->executeQuery()->fetchAllAssociative();
}
/**
* @param array|null $filtro
* @return array
*/
public function gerarBandaHistoricaDecil()
{
$sql = "SELECT
id_indicador
, nome_indicador
, interpretacao
, jsonb_agg(jsonb_build_object((percentil * 100)::int, valor) ORDER BY (percentil * 100)::int ASC)
FROM generate_series(0,1,0.1) percentil
JOIN LATERAL(
SELECT
id_indicador
, nome_indicador
, ficha_tecnica->>'interpretacao' interpretacao
, CASE WHEN ficha_tecnica->>'interpretacao' = 'MENOR' THEN percentile_cont(percentil) WITHIN GROUP (ORDER BY valor DESC) ELSE percentile_cont(percentil) WITHIN GROUP (ORDER BY valor ASC) END valor
FROM dados.calculo
JOIN modelagem.indicador USING(id_indicador)
GROUP BY 1,2,3, ficha_tecnica
) a ON TRUE
--WHERE interpretacao IS NOT NULL
GROUP BY 1,2,3
ORDER BY 1,2";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function findModelagensWithCountGruposAvaliadosIndicadores(array $periodos, array $programa, string $gestor_permissoes)
{
$sql = "SELECT
id_modelagem,
nome_modelagem,
COUNT(DISTINCT id_grupo) qtd_grupos,
COUNT(DISTINCT id_avaliado) qtd_avaliados,
COUNT(DISTINCT id_indicador) qtd_indicadores
FROM dados.calculo
WHERE TRUE
{$periodos['where']}
{$programa['where']}
{$gestor_permissoes}
GROUP BY 1,2";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function findMediasPerformanceAbsolutoAnual(array $programa, int $idIndicador, string $ano, ?array $especialidade = null)
{
$whereGrupo = null;
if (!is_null($especialidade)) {
$whereGrupo = ' AND id_grupo = ' . $especialidade['id'];
}
$sql = "SELECT
id_indicador,
nome_indicador,
unidade_indicador,
JSONB_AGG(
JSONB_BUILD_OBJECT(
'periodo', periodo,
'performance', performance,
'absoluto', absoluto,
'qtd_avaliados', qtd_avaliados
)
) periodos
FROM (
SELECT
id_indicador,
nome_indicador,
unidade_indicador,
CONCAT(periodo->>'ano', periodo->>'periodo')::integer periodo,
ROUND(AVG(performance), 2) performance,
ROUND(AVG(valor), 2) absoluto,
COUNT(DISTINCT id_avaliado) qtd_avaliados
FROM dados.calculo
WHERE CONCAT(periodo->>'ano', periodo->>'periodo')::integer BETWEEN %s AND %s
{$programa['where']}
{$whereGrupo}
AND id_indicador = {$idIndicador}
GROUP BY 1,2,3,4
ORDER BY periodo
) a
GROUP BY 1,2,3";
$sql = sprintf($sql, explode('-', $ano)[0], explode('-', $ano)[1]);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAssociative();
}
public function getMediaSomaScore(array $periodos, ?array $param = null)
{
$selectJSON = ", nome_dominio";
if ( isset($param['filter_avaliado']) ) {
$selectJSON = ", CONCAT(nome_avaliado, ' - ', nome_dominio)";
}
if ( isset($param['filter_grupo']) ) {
$selectJSON = ", CONCAT(nome_grupo, ' - ', nome_dominio)";
}
$avaliadoSQL['select'] = isset($param['filter_avaliado']) ? ', id_avaliado, nome_avaliado' : '';
$avaliadoSQL['where'] = isset($param['filter_avaliado']) ? " AND id_avaliado IN ({$param['avaliados']})" : "";
$avaliadoSQL['orderBy'] = isset($param['filter_avaliado']) ? 'nome_avaliado, ' : '';
$dominioSQL['where'] = !empty($param['dominios']) ? " AND id_dominio IN ({$param['dominios']})" : "";
$grupoSQL['select'] = isset($param['filter_grupo']) ? !empty($param['especialidades']) ? ', nome_grupo' : '' : '';
$grupoSQL['where'] = isset($param['filter_grupo']) ? !empty($param['especialidades']) ? " AND id_grupo IN ({$param['especialidades']})" : "" : "";
$grupoSQL['orderBy'] = isset($param['filter_grupo']) ? 'nome_grupo, ' : '';
$sql = "SELECT
ROUND( AVG(performance) FILTER(WHERE soma_score IS NOT NULL), 2) media_scores,
id_dominio
$selectJSON AS nome_dominio,
periodo
{$avaliadoSQL['select']}
{$grupoSQL['select']}
FROM (
SELECT
COALESCE(b.soma_score, 0) soma_score,
CASE
WHEN soma_score IS NOT NULL THEN ((soma_score / soma_peso) * 100)
ELSE null
END performance,
b.id_dominio,
b.nome_dominio,
b.periodo
{$avaliadoSQL['select']}
{$grupoSQL['select']}
FROM (
SELECT
SUM(a.score) AS soma_score,
SUM(a.peso) AS soma_peso,
a.periodo,
a.id_dominio,
a.nome_dominio
{$avaliadoSQL['select']}
{$grupoSQL['select']}
FROM (
SELECT
{$periodos['select']},
score,
ROUND(AVG(peso), 2) peso,
id_dominio,
nome_dominio
{$avaliadoSQL['select']}
{$grupoSQL['select']}
FROM dados.calculo
WHERE TRUE {$dominioSQL['where']}{$periodos['where']}{$avaliadoSQL['where']}{$grupoSQL['where']}
GROUP BY periodo, id_dominio, nome_dominio, score{$avaliadoSQL['select']}{$grupoSQL['select']}
) a
GROUP BY a.periodo, a.id_dominio, a.nome_dominio{$avaliadoSQL['select']}{$grupoSQL['select']}
ORDER BY {$avaliadoSQL['orderBy']}{$grupoSQL['orderBy']}a.id_dominio, a.periodo
) b
) c
GROUP BY c.periodo, c.id_dominio, c.soma_score, c.nome_dominio{$avaliadoSQL['select']}{$grupoSQL['select']}
ORDER BY {$avaliadoSQL['orderBy']}{$grupoSQL['orderBy']}c.id_dominio, c.periodo";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function getAvaliados($grupos = null, int $id_modelagem)
{
$sql = sprintf(
"SELECT
DISTINCT(id_avaliado) AS id_avaliado,
nome_avaliado,
id_grupo,
nome_grupo AS grupo
FROM dados.calculo
WHERE TRUE %s AND id_modelagem = {$id_modelagem}
ORDER BY id_grupo",
$grupos ? sprintf('AND id_grupo IN(%s)', filter_var($grupos, FILTER_SANITIZE_STRING)) : ''
);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function findDominios(int $id_modelagem)
{
$sql = "SELECT DISTINCT id_dominio,
nome_dominio AS titulo
FROM dados.calculo
WHERE id_modelagem = {$id_modelagem}
ORDER BY 1";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function findGrupos(int $id_modelagem)
{
$sql = "SELECT
DISTINCT id_grupo,
nome_grupo AS titulo
FROM dados.calculo
WHERE id_modelagem = {$id_modelagem}
ORDER BY 1";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function findIndicadores(int $idModelagem, ?int $idBusca = null)
{
$whereGrupo = '';
if (!is_null($idBusca) && $idBusca != 0) {
$whereGrupo = " AND id_grupo = {$idBusca}";
}
$sql = "SELECT DISTINCT
id_indicador,
nome_indicador
FROM dados.calculo
WHERE id_modelagem = {$idModelagem}
{$whereGrupo}";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function findIndicadoresWithoutModelagem(?int $idBusca = null)
{
$whereGrupo = '';
if (!is_null($idBusca) && $idBusca != 0) {
$whereGrupo = " AND id_grupo = {$idBusca}";
}
$sql = "SELECT DISTINCT
id_indicador,
nome_indicador
FROM dados.calculo
WHERE TRUE
{$whereGrupo}";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function findPerformanceIndicadorAvaliado(array $periodo, int $idModelagem, int $idIndicador, ?int $idBusca = null, bool $evs = true)
{
$toChar = '990D99%';
$alias = 'evs';
$campo = 'performance';
if (!$evs) {
$alias = 'gps';
}
$whereGrupo = "";
if (!is_null($idBusca) && $idBusca != 0) {
$whereGrupo = " AND id_grupo = {$idBusca}";
}
$sql = "SELECT
id_avaliado,
nome_avaliado,
id_grupo,
nome_grupo,
CONCAT(periodo->>'ano', periodo->>'periodo')::integer periodo,
{$campo} {$alias},
Trim(To_Char({$campo}, '{$toChar}')) {$alias}_txt,
Round(Avg({$campo}) OVER(PARTITION BY id_grupo, id_avaliado), 2) AS {$alias}_anual,
Trim(To_Char(Round(Avg({$campo}) OVER(PARTITION BY id_grupo, id_avaliado), 2), '{$toChar}')) AS {$alias}_anual_txt,
true is_producao,
Substring(CONCAT(periodo->>'ano', periodo->>'periodo')::text,5,2)::integer periodo_mes,
To_Char(((CONCAT(periodo->>'ano', periodo->>'periodo'))::text||'01')::date,'MM')::int periodo_txt
FROM dados.calculo
WHERE TRUE
AND id_modelagem = {$idModelagem}
AND id_indicador = {$idIndicador}
{$periodo['where']}
{$whereGrupo}
ORDER BY {$alias}_anual DESC, CONCAT(periodo->>'ano', periodo->>'periodo')::integer, id_avaliado";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery();
}
public function findPerformanceIndicadorEspecialidade(array $periodo, int $idModelagem, int $idIndicador, ?int $idBusca = null, bool $evs = true)
{
$toChar = '990D99%';
$alias = 'evs';
$campo = 'performance';
if (!$evs) {
$alias = 'gps';
}
$whereGrupo = "";
if (!is_null($idBusca) && $idBusca != 0) {
$whereGrupo = " AND id_grupo = {$idBusca}";
}
$sql = "SELECT
{$alias}.id_grupo
, MAX({$alias}.nome_grupo) AS nome_grupo
, {$alias}.periodo
, ROUND(AVG({$alias}.{$alias}), 2) AS {$alias}
, TRIM(TO_CHAR(ROUND(AVG({$alias}.{$alias}), 2), '{$toChar}')) AS {$alias}_txt
, ROUND(AVG({$alias}.{$alias}_anual), 2) AS {$alias}_anual
, MAX({$alias}.{$alias}_anual_txt) AS {$alias}_anual_txt
, SUBSTRING({$alias}.periodo::text, 5, 2)::integer periodo_mes
, TO_CHAR((({$alias}.periodo)::text || '01')::date, 'MM')::int periodo_txt
FROM (
SELECT
id_grupo,
nome_grupo,
CONCAT(periodo->>'ano', periodo->>'periodo')::integer periodo,
{$campo} {$alias},
ROUND(AVG({$campo}) OVER(PARTITION BY id_grupo), 2) AS {$alias}_anual,
TRIM(TO_CHAR(ROUND(AVG({$campo}) OVER(PARTITION BY id_grupo), 2), '{$toChar}')) AS {$alias}_anual_txt,
true is_producao,
SUBSTRING(CONCAT(periodo->>'ano', periodo->>'periodo')::text,5,2)::integer periodo_mes,
TO_CHAR(((CONCAT(periodo->>'ano', periodo->>'periodo'))::text||'01')::date,'MM')::int periodo_txt
FROM dados.calculo
WHERE TRUE
AND id_modelagem = {$idModelagem}
AND id_indicador = {$idIndicador}
{$periodo['where']}
{$whereGrupo}
) {$alias}
GROUP BY id_grupo, periodo
ORDER BY {$alias}.id_grupo, {$alias}.periodo
";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery();
}
public function findAvaliadosSemProducao(array $periodo, int $idModelagem, int $idIndicador, ?int $idBusca = null, bool $evs = true)
{
$toChar = '990D99%';
$alias = 'evs';
$campo = 'performance';
if (!$evs) {
$alias = 'gps';
}
$whereGrupo = "";
if (!is_null($idBusca) && $idBusca != 0) {
$whereGrupo = " AND id_grupo = {$idBusca}";
}
$sql = "select
*
from (
select
a.id_avaliado
, a.nome_avaliado
, a.id_grupo
, a.nome_grupo
, jsonb_agg(DISTINCT CASE WHEN CONCAT(periodo->>'ano',periodo->>'periodo') <> '' THEN CONCAT(periodo->>'ano',periodo->>'periodo') END) periodos
from modelagem.scorecard_avaliados a
left join dados.evs b ON a.id_programa = b.id_programa AND a.id_modelagem = b.id_modelagem AND a.id_grupo = b.id_grupo AND a.id_avaliado = b.id_avaliado AND CONCAT(periodo->>'ano',periodo->>'periodo')::int BETWEEN ".$periodo['from']['ano'].$periodo['from']['periodo']." AND ".$periodo['to']['ano'].$periodo['to']['periodo']."
WHERE ".$periodo['from']['ano'].$periodo['from']['periodo']." BETWEEN avaliacao_inicio AND avaliacao_fim AND ".$periodo['to']['ano'].$periodo['to']['periodo']." BETWEEN avaliacao_inicio AND avaliacao_fim
GROUP BY 1,2,3,4
) a
WHERE periodos = '[null]'::jsonb
ORDER BY 4";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery();
}
public function findPerformanceIndicadorEspecialidadeFesp(array $periodo, int $idModelagem, int $idIndicador, ?int $idBusca = null, bool $evs = true)
{
$sql = "select
id_modelagem
, nome_modelagem
, id_grupo
, nome_grupo
, CONCAT(periodo->>'ano',periodo->>'periodo') As periodo
, CONCAT(periodo->>'periodo', '/', periodo->>'ano') AS periodo_txt
, REPLACE(ROUND(AVG(valor), 2)::text, '.', ',') AS evs
from dados.evs
WHERE TRUE {$periodo['where']}
GROUP BY 1,2,3,4,5,6
order by 3,5";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery();
}
public function findPerformanceIndicadorAvaliadoRede(array $periodo, int $idIndicador, ?int $idBusca = null, bool $evs = true)
{
$toChar = '990D99%';
$alias = 'evs';
$campo = 'performance';
if (!$evs) {
$alias = 'gps';
}
$whereGrupo = "";
if (!is_null($idBusca) && $idBusca != 0) {
$whereGrupo = " AND id_grupo = {$idBusca}";
}
$sql = "SELECT
id_avaliado,
nome_avaliado,
id_grupo,
nome_grupo,
id_modelagem,
nome_modelagem,
CONCAT(periodo->>'ano', periodo->>'periodo')::integer periodo,
{$campo} {$alias},
Trim(To_Char({$campo}, '{$toChar}')) {$alias}_txt,
Round(Avg({$campo}) OVER(PARTITION BY id_grupo, id_modelagem, id_avaliado), 2) AS {$alias}_anual,
Trim(To_Char(Round(Avg({$campo}) OVER(PARTITION BY id_grupo, id_modelagem, id_avaliado), 2), '{$toChar}')) AS {$alias}_anual_txt,
true is_producao,
Substring(CONCAT(periodo->>'ano', periodo->>'periodo')::text,5,2)::integer periodo_mes,
To_Char(((CONCAT(periodo->>'ano', periodo->>'periodo'))::text||'01')::date,'MM')::int periodo_txt
FROM dados.calculo
WHERE TRUE
AND id_indicador = {$idIndicador}
{$periodo['where']}
{$whereGrupo}
ORDER BY {$alias}_anual DESC, CONCAT(periodo->>'ano', periodo->>'periodo')::integer, id_avaliado";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery();
}
public function findEvolucaoAnualIndicadorAvaliado(int $idAvaliado, int $idGrupo, int $idModelagem, int $idIndicador, array $periodo, string $campo = 'evs')
{
$sql = "SELECT
id_avaliado,
nome_avaliado,
CONCAT(periodo->>'ano', periodo->>'periodo')::integer periodo,
ROUND(performance, 2) {$campo}
FROM dados.calculo
WHERE
id_avaliado = {$idAvaliado}
AND id_grupo = {$idGrupo}
AND id_modelagem = {$idModelagem}
AND id_indicador = {$idIndicador}
{$periodo['where']}";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
public function findEvolucaoAnualIndicadorGrupo(int $idGrupo, int $idModelagem, int $idIndicador, array $periodo, string $campo = 'evs')
{
$sql = "SELECT
id_grupo,
nome_grupo,
CONCAT(periodo->>'ano', periodo->>'periodo')::integer periodo,
ROUND(AVG(performance), 2) {$campo}
FROM dados.calculo
WHERE
id_grupo = {$idGrupo}
AND id_modelagem = {$idModelagem}
AND id_indicador = {$idIndicador}
{$periodo['where']}
GROUP BY 1,2,3";
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
/**
* @return array
*/
public function getDetalhesDesempenhoIndicadorRastreabilidade(int $id_indicador, int $periodo, array $filtros, array $programa, int $id_avaliado)
{
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$sql = "SELECT * FROM dados.rastreabilidade JOIN modelagem.indicador USING(id_indicador) WHERE id_indicador = %s AND id_avaliado = %s AND CONCAT(periodo->>'ano',periodo->>'periodo')::int = %s %s";
$sql = sprintf($sql, $id_indicador, $id_avaliado, $periodo, $programa['where']);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAssociative();
}
/**
* @return array
*/
public function getDetalhesDesempenhoIndicadorRastreabilidadeDrg(int $id_indicador, int $periodo, array $filtros, array $programa, int $id_avaliado)
{
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$sql = "SELECT * FROM dados.rastreabilidade JOIN modelagem.indicador USING(id_indicador) WHERE id_indicador = %s AND id_avaliado = %s AND CONCAT(periodo->>'ano',periodo->>'periodo')::int = %s %s";
$sql = "SELECT
*
FROM dados.drg
JOIN modelagem.indicador USING(id_indicador)
WHERE id_indicador = %s AND id_avaliado = %s AND CONCAT(periodo->>'ano',periodo->>'periodo')::int = %s %s";
$sql = sprintf($sql, $id_indicador, $id_avaliado, $periodo, $programa['where']);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAllAssociative();
}
/**
* @return array
*/
public function getCalculo(int $id_indicador, int $periodo, array $filtros, array $programa, int $id_avaliado)
{
$whereFiltro = '';
if (count($filtros) > 0) {
foreach ($filtros as $filtro) {
$whereFiltro .= $filtro . ' ';
}
}
$sql = "SELECT * FROM dados.calculo JOIN modelagem.indicador USING(id_indicador) WHERE id_indicador = %s AND id_avaliado = %s AND CONCAT(periodo->>'ano',periodo->>'periodo')::int = %s %s";
$sql = sprintf($sql, $id_indicador, $id_avaliado, $periodo, $programa['where']);
$stmt = $this->_em->getConnection()->prepare($sql);
return $stmt->executeQuery()->fetchAssociative();
}
}

src/Repository/Cliente/Dados/CalculoRepository.php line 1258