src/DataProvider/Analytics.php line 102

  1. <?php
  2. // api/src/DataProvider/BlogPostCollectionDataProvider.php
  4. namespace App\DataProvider;
  5. use App\Common\Functions\AggregateFuns;
  6. use Symfony\Component\HttpFoundation\Response;
  7. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  8. use App\Common\Functions\Helpers;
  9. use App\Functions\Common\Variables;
  10. use Doctrine\ODM\MongoDB\DocumentManager as MongoDBDocumentManager;
  11. use Symfony\Component\HttpFoundation\Request;
  12. use Symfony\Component\PropertyAccess\PropertyAccess;
  13. use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
  14. use Symfony\Component\Serializer\SerializerInterface;
  15. use Symfony\Component\Validator\Validator\ValidatorInterface;
  16. class Analytics extends AbstractController
  17. {
  18.   protected $headers = array('Content-Type', 'application/json');
  19.     public $propertyAccessor;
  20.     private $groups_functions;
  21.     private $options = Variables::SERIALIZER_OPTIONS;
  22.     public function __construct(public string $rootPath, public MongoDBDocumentManager $dm, public SerializerInterface $serializer, public ValidatorInterface $validator)
  23.     {
  24.         $this->groups_functions = ["date"=>fn($x)=>(['$dateToString'=>['format'=>$x->format, 'date'=>'$'.$x->field]]), 'main'=>fn($x)=>('$'.$x)];
  25.         $this->propertyAccessor = PropertyAccess::createPropertyAccessor();
  26.         $this->options[AbstractNormalizer::CIRCULAR_REFERENCE_LIMIT] = 3;
  27.         $this->options[AbstractNormalizer::CIRCULAR_REFERENCE_HANDLER] = function($object){
  28.           if(method_exists($object, 'getId')){
  29.             return $object->getId();
  30.           }
  31.           return $object;
  32.         };
  33.     }
  34.     private function grouping($main_query, $query, $groups){
  35.         $gr_exp = $main_query->expr();
  36.         foreach($groups as $kg=>$group){
  37.             $val = $group['date']??$group;
  38.             if(is_array($val)){
  39.                 $val = (object) $val;
  40.             }
  41.             $fun = $this->groups_functions[$group['fun'] ?? 'main'];
  42.             $gr_exp = $gr_exp->field($group['key'] ?? $kg)->expression($fun($val));
  43.         }
  44.         return $query->group()
  45.             ->field('id')
  46.             ->expression(
  47.                 $gr_exp
  48.             );
  49.     }
  50.     private function applyField($model, $query, $type='main'){
  51.         $file = str_replace('App\\Document\\', 'Reports\\', $model).'.json';
  52.         $file = str_replace('\\', '/', $file);
  53.         $data = file_get_contents($this->rootPath.'/'.$file);
  54.         $var = json_decode($data, true);
  55.         $fields = $var[$type] ?? [];
  56.         foreach ($fields as $key=>$field){
  57.             $fun = $field['fun'] ?? $field;
  58.             $fi = $field['field'] ?? '$'.$key;
  59.             $query = $query->field($key)->{$fun}($fi);
  60.         }
  61.         return $query;
  62.     }
  63.     private function applyAnalysis($model, $filters, $groups, $params=[])
  64.     {
  65.         $main_query = $this->dm->createAggregationBuilder($model);
  66.         $cs = Helpers::get_model_config($model);
  67.         $query = $main_query;
  68.         if(count($filters)){
  69.             $query = $query->match()->addAnd($filters);
  70.         }
  71.         $out = Helpers::getModelFilter($cs->filters ?? []);
  72.           if(count($out)>0){
  73.           if(!count($filters)){
  74.             $query = $query->match();
  75.           }
  76.           $query = $query->addAnd($out);
  77.         }
  78.         $m_aggs = [...$cs->aggregation['analysis'] ?? [], ...($params['aggs'] ?? [])];
  79.         foreach ($m_aggs as $agg => $val) {
  80.           $query = AggregateFuns::{$val['agg'] ?? $agg}($query, array_diff_key($val, ['agg' => null]));
  81.         }
  82.         $query = $this->grouping($main_query, $query, $groups);
  83.         $query = $query->field('counts')
  84.                            ->sum(1);
  85.         $query = $this->applyField($model, $query, $params['analysis'] ?? 'main');
  86.         return $query->execute();
  87.     }
  88.     private function applyListAnalysis($model, $filters, $groups, $include_data=false)
  89.     {
  90.         $main_query = $this->dm->createAggregationBuilder($model);
  91.         $query = $main_query;
  92.         if(count($filters)){
  93.             $query = $query->match()->addAnd($filters);
  94.         }
  95.         $query = $this->grouping($main_query, $query, $groups);
  96.         $query = $query->field('count')->sum(1)->field('ids')->push('$_id');
  97.         if($include_data){
  98.             return $query->field('data')->push('$$ROOT')->execute();
  99.         }
  100.         return $query->execute();
  101.     }
  102.     public function analysis(Request $request)
  103.     {
  104.         $data = $request->request->all();
  105.         $this->dm->clear(); // to fix fetching from proxy
  106.         $out = [];
  107.         foreach($data as $key=>$val){
  108.             $model = Helpers::get_module($val['model'] ?? $key);
  109.             $filters = $val['filter'] ?? [];
  110.             $groups = $val['group'] ?? [];
  111.             $out[$key] =$this->applyAnalysis($model, $filters, $groups, $val);
  112.         }
  113.         $res = $this->serializer->serialize($out, 'json');
  114.         return new Response($res, Response::HTTP_OK, ['Content-Type' => 'application/json']);
  115.     }
  116.     public function listAnalysis(Request $request)
  117.     {
  118.         $data = $request->request->all();
  119.         $this->dm->clear(); // to fix fetching from proxy
  120.         $out = [];
  121.         foreach($data as $key=>$val){
  122.             $model = Helpers::get_module($val['model'] ?? $key);
  123.             $filters = $val['filter'] ?? [];
  124.             $groups = $val['group'] ?? [];
  125.             $out[$key] =$this->applyListAnalysis($model, $filters, $groups, $val['include'] ?? false);
  126.         }
  127.         $res = $this->serializer->serialize($out, 'json');
  128.         return new Response($res, Response::HTTP_OK, ['Content-Type' => 'application/json']);
  129.     }
  130. }