src/Common/Functions/DbFunction.php line 425

  1. <?php
  3. namespace App\Common\Functions;
  5. use App\Common\Functions\Filters\Main;
  6. use App\Functions\Common\Variables;
  7. use App\Functions\PreSave\Main as PreSaveMain;
  8. use Symfony\Component\Mercure\Hub;
  9. use Symfony\Component\Mercure\Jwt\StaticTokenProvider;
  10. use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
  12. class DbFunction
  13. {
  14.   public const HUB_URL = 'https://mer-hub.ukkera.com/.well-known/mercure';
  15.   public const TOKEN = 'eyJhbGciOiJIUzI1NiJ9.eyJtZXJjdXJlIjp7InB1Ymxpc2giOlsiKiJdLCJwYXlsb2FkIjp7InVzZXIiOiJodHRwczovL2Npa2kudWtrZXJhLmNvbS8iLCJyZW1vdGVBZGRyIjoiMTI3LjAuMC4xIn19fQ.yb2G4txCdqFgIaoXSg41UDVsEq1TptEMSIBUKlII92E';
  17.   public static function FetchExtra($dm, $fetch)
  18.   {
  19.     $value = [];
  20.     foreach ($fetch as $key => $item) {
  21.       $value[$key] = self::fetchWithKeys($dm, $item['filters'] ?? [], $item['keys'] ?? ['id'], $item['module'] ?? $key, $item['aggs'] ?? [], $item['props'] ?? ['hydrate' => true]);
  22.     }
  24.     return $value;
  25.   }
  27.   public static function buildHub()
  28.   {
  29.     $hub = new Hub(self::HUB_URL, new StaticTokenProvider(self::TOKEN));
  31.     return $hub;
  32.   }
  34.   public static function AddOrUpdateModel($module, $dm, $serializer, $ev)
  35.   {
  36.     $model = Helpers::get_module($module);
  37.     $repo = $dm->getRepository($model);
  38.     $db_val = null;
  39.     if ($ev['id'] ?? false) {
  40.       $db_val = $repo->findOneBy(['id' => $ev['id']]);
  41.     }
  43.     return self::AddOrUpdate($model, $dm, $serializer, $ev, $db_val);
  44.   }
  46.   public static function AddOrUpdate($model, $dm, $serializer, $ev, $db_val = null, $props = [], $params = [])
  47.   {
  48.     $cs = Helpers::get_model_config($model);
  49.     $pre_save = Helpers::getFun($model, 'PreSave');
  50.     $hooks = $cs->hooks ?? [];
  51.     $validate_fun = Helpers::getFun($model, 'Validations');
  52.     $repo = $dm->getRepository($model);
  53.     $translations = $ev['translate'] ?? [];
  54.     $id = $ev['id'] ?? $ev['pid'] ?? null;
  55.     if ($cs->edits ?? false) {
  56.       Helpers::mapping_from_account($ev, $cs->edits);
  57.     }
  58.     if ($cs->inits ?? false) {
  59.       Helpers::inits_functions($ev, $cs->inits);
  60.     }
  61.     if ($id && !$db_val) {
  62.       $db_val = $repo->findOneBy(['id' => $id]);
  63.     }
  64.     if ($id && ($db_val ?? false)) {
  65.       $saves = $serializer->deserialize(json_encode($ev), $model, 'json', [...Variables::DESERIALZER_OPTIONS, ObjectNormalizer::DEEP_OBJECT_TO_POPULATE => true, 'object_to_populate' => clone $db_val, 'dm' => $dm, 'serializer' => $serializer, 'creating' => false]);
  66.       if ($pre_save) {
  67.         $saves->creating = false;
  68.         $saves->remove = $ev['remove'] ?? false;
  69.         $pre_save->invoke((object) [], $dm, $saves, $serializer, $db_val, $props, $params);
  70.       }
  71.       if($hooks['pre_save'] ?? false) {
  72.         $saves->creating = false;
  73.         $saves->remove = $ev['remove'] ?? false;
  74.         PreSaveMain::handler($hooks['pre_save'], $dm, $saves, $serializer, $db_val, $props, $params);
  75.       }
  76.       // dd($saves, $ev, $db_val->app, $saves->app);
  77.       $dm->merge($saves);
  78.       $dm->flush();
  79.       if ($ev['remove'] ?? false) {
  80. //          try{
  81. //          dd(get_class_methods($db_val));
  82.         $can_remove = $db_val->checkRemoval();
  83.         if (!$can_remove) {
  84.           return ['error' => 'cannot remove this data'];
  85.         }
  86.         $dm->remove($db_val);
  87. //          }catch(\Exception $ex){
  88. //            $dm->persist($db_val);
  89. //          }
  90.         $dm->flush();
  92.         return null;
  93.       }
  94.       self::CreateTranslations($saves, $dm, $translations);
  96.       return $id;
  97.     }
  98.     if ($ev['remove'] ?? false) {
  99.       return null;
  100.     }
  101.     if ($cs->mappings ?? false) {
  102.       Helpers::mapping_from_account($ev, $cs->mappings);
  103.     }
  104.     $value = $serializer->deserialize(json_encode($ev), $model, 'json', [...Variables::DESERIALZER_OPTIONS, 'dm' => $dm, 'serializer' => $serializer, 'creating' => true]);
  105.     if ($validate_fun) {
  106.       $v_out = $validate_fun->invoke((object) [], $dm, $value, $serializer, (object) [], $props, $params);
  107.       if ($v_out) {
  108.         return $v_out->getId();
  109.       }
  110.     }
  111.     if ($cs->generate ?? false) {
  112.       if (!$id) {
  113.         $id = Main::generate_id_from_vals($value, $cs->generate);
  114.       }
  115.     }
  116.     if ($id) {
  117.       $value->id = $id;
  118.     }
  119.     $dm->persist($value);
  120.     $dm->flush();
  121.     if ($pre_save) {
  122.       $value->creating = true;
  123.       try {
  124.         $pre_save->invoke((object) [], $dm, $value, $serializer, (object) [], $props, $params);
  125.         if($hooks['pre_save'] ?? false) {
  126.           PreSaveMain::handler($hooks['pre_save'], $dm, $value, $serializer, $db_val, $props, $params);
  127.         }
  128.       } catch (\Throwable $ex) {
  129.         $dm->remove($value);
  130.         $dm->flush();
  131.         dd($ex);
  132.       }
  133.     }
  134.     $serializer->deserialize(json_encode([...$ev, 'id' => $value->id]), $model, 'json', ['object_to_populate' => clone $value, ObjectNormalizer::DEEP_OBJECT_TO_POPULATE => true, ...Variables::DESERIALZER_OPTIONS, 'dm' => $dm, 'serializer' => $serializer, 'creating' => false]);
  135.     $dm->flush();
  136.     self::CreateTranslations($value, $dm, $translations);
  138.     return $value->id;
  139.   }
  141.   public static function FindTranslations($mainValue, $dm)
  142.   {
  143.     $repository = $dm->getRepository('\\Gedmo\\Translatable\\Document\\Translation');
  145.     return $repository->findTranslations($mainValue);
  146.   }
  148.   public static function runModuleValidation($module, $inputs, $dm, $serializer, $props, $params)
  149.   {
  150.     $model = Helpers::get_module($module);
  151.     $error_validation_fun = Helpers::getFun($model, 'ErrorValidations');
  152.     if ($error_validation_fun) {
  153.       foreach ($inputs as $key => $values) {
  154.         foreach ($values as $vs => $value) {
  155.           $v_out = $error_validation_fun->invoke((object) [], $dm, (object) $value, $serializer, (object) [], $props, $params);
  156.           if ($v_out) {
  157.             return $v_out;
  158.           }
  159.         }
  160.       }
  161.     }
  162.   }
  164.   public static function GetByIds($model, $em, $data, $col, $key = 'id')
  165.   {
  166.     $entity = Helpers::get_module($model)['model'];
  167.     $ids = $col ? array_column($data, $col) : $data;
  168.     // dd($ids);
  169.     $qb = $em->createQueryBuilder();
  170.     $qb->select('m');
  171.     $qb->from($entity, 'm');
  172.     $qb->where($qb->expr()->in("m.$key", '?1'));
  174.     return $qb->setParameters(['1' => $ids])->getQuery()->getResult();
  175.   }
  177.   public static function resetUserPassword($dm, $user, $password)
  178.   {
  179.     if ($user) {
  180.       $user->reset_code = null;
  181.       $user->reset_code_date = null;
  182.       $user->setPassword($password);
  183.       $dm->persist($user);
  184.       $dm->flush();
  185.     }
  186.   }
  188.   public static function CreateTranslations($mainValue, $dm, $translations)
  189.   {
  190.     if (count($translations)) {
  191.       $repository = $dm->getRepository('\\Gedmo\\Translatable\\Document\\Translation');
  192.       foreach ($translations as $field => $value) {
  193.         foreach ($value as $lang => $val) {
  194.           $repository->translate($mainValue, $field, $lang, $val);
  195.         }
  196.         $repository->translate($mainValue, $field, 'en', $mainValue->{$field});
  197.       }
  198.       $dm->flush();
  199.     }
  200.   }
  202.   public static function FindAndUpdateModel($module, $dm, $serializer, $ev)
  203.   {
  204.     $model = Helpers::get_module($module);
  205.     $id = $ev['id'];
  206.     unset($ev['id']);
  207.     $qb = $dm->createQueryBuilder($model)
  208.       // Find the job
  209.       ->findAndUpdate()
  210.       ->field('id')->equals($id);
  211.     foreach ($ev as $k => $val) {
  212.       $qb = $qb->field($k)->set($val);
  213.     }
  214.     $qb->getQuery()->execute();
  216.     return true;
  217.   }
  219.   public static function findModelBy($dm, $module, $vals)
  220.   {
  221.     $model = Helpers::get_module($module);
  223.     return $dm->getRepository($model)->findOneBy($vals);
  224.   }
  226.   public static function CheckAddModel($dm, $module, $value, $filters, $serializer)
  227.   {
  228.     $model = Helpers::get_module($module);
  229.     $db_value = self::findModelBy($dm, $module, $filters);
  230.     $_id = self::AddOrUpdate($model, $dm, $serializer, (array) $value, $db_value);
  232.     return $db_value;
  233.   }
  235.   public static function UpdateModelWithValue($dm, $value, $model, $val, $serializer)
  236.   {
  237.     $db_value = $serializer->deserialize(json_encode($value), $model, 'json', [...Variables::DESERIALZER_OPTIONS, ObjectNormalizer::DEEP_OBJECT_TO_POPULATE => true, 'object_to_populate' => clone $val, 'dm' => $dm, 'serializer' => $serializer, 'creating' => false]);
  238.     $dm->persist($db_value);
  239.     $dm->flush();
  241.     return $db_value;
  242.   }
  244.   public static function UpdateModel($dm, $repo, $model, $value, $vals, $serializer)
  245.   {
  246.     $val = $repo->findOneBy($vals);
  247.     if ($val) {
  248.       return self::UpdateModelWithValue($dm, $value, $model, $val, $serializer);
  249.     }
  251.     return null;
  252.   }
  254.   public static function checkUniq($collection, $key, $value, $id, $extra = [])
  255.   {
  256.     $trimmed = trim(preg_replace('/\s+/', ' ', $value));
  257.     $val = new \MongoDB\BSON\Regex('^'.$trimmed.'$', 'i');
  258.     $exists = $collection->findOneBy([$key => $val, ...$extra]);
  260.     if ($exists && $exists->id != $id) {
  261.       return "{$key} at {$value} is already Exist";
  262.     }
  263.   }
  265.   public static function FetchWithAggregation($dm, $module, $filters = [], $aggs = [], $props = [])
  266.   {
  267.     $model = Helpers::get_module($module);
  268.     $cs = Helpers::get_module_config($module);
  269.     $query = $dm->createAggregationBuilder($model);
  270.     if ($props['hydrate'] ?? false) {
  271.       $query = $query->hydrate($model);
  272.     }
  273.     $class = new $model();
  274.     $out = Helpers::getModelFilter($cs->filters ?? []);
  275.     $query = $query->match();
  276.     if (count($out) > 0) {
  277.       $query = $query->addAnd($out);
  278.     }
  279.     $pre_filter = $props['pre_filter'] ?? [];
  280.     foreach ($pre_filter as $agg => $val) {
  281.       $query = AggregateFuns::{$val['agg'] ?? $agg}($query, array_diff_key($val, ['agg' => null]));
  282.       $query = $query->match();
  283.     }
  284.     if (count($filters) > 0) {
  285.       $query = $query->addAnd($filters);
  286.     } else {
  287.       $query = $query->addAnd(['id' => ['$exists' => true]]);
  288.     }
  289.     foreach ($aggs as $agg => $val) {
  290.       $query = AggregateFuns::{$val['agg'] ?? $agg}($query, array_diff_key($val, ['agg' => null]));
  291.     }
  292.     if ($props['agg'] ?? false) {
  293.       $m_aggs = $cs->aggregation[$props['agg']] ?? [];
  294.       foreach ($m_aggs as $agg => $val) {
  295.         $query = AggregateFuns::{$val['agg'] ?? $agg}($query, array_diff_key($val, ['agg' => null]));
  296.       }
  297.     }
  298.     if ($props['limit'] ?? false) {
  299.       $query = $query->limit($props['limit']);
  300.     }
  302.     return $query->execute();
  303.   }
  305.   public static function RemoveAC($x)
  306.   {
  307.     $x['updated_at'] = new \MongoDB\BSON\UTCDateTime();
  308.     if ('create' == $x['ac']) {
  309.       $x['created_at'] = $x['updated_at'];
  310.     }
  311.     unset($x['ac']);
  312.     unset($x['md']);
  314.     return $x;
  315.   }
  317.   public static function fetchWithKeys($dm, $filters, $keys, $module = 'collect__payment', $aggs = [], $props = [])
  318.   {
  319.     $data = self::FetchWithAggregation($dm, $module, $filters, $aggs, $props);
  321.     return Main::multiKeys(['levels' => $keys], $data, []);
  322.   }
  323.   public static function fetchWithBuildIds($dm, $filters, $keys, $module = 'collect__payment', $aggs = [], $props = [])
  324.   {
  325.     $data = self::FetchWithAggregation($dm, $module, $filters, $aggs, $props);
  327.     return Main::buildIdKeys(['levels' => $keys], $data, []);
  328.   }
  330.   public static function bulkDataInsert($dm, $data, $serializer = null, $params = [])
  331.   {
  332.     $total = array_sum(array_map(fn ($x) => count($x), $data));
  333.     $count = $params['count'] ?? 2000;
  334.     if ($params['updateProgress'] ?? false) {
  335.       $params['updateProgress'](['progress' => 1, 'status' => 'start processing']);
  336.     }
  337.     $inserted = 0;
  339.     foreach ($data as $module => $mds) {
  340.       $model = Helpers::get_module($module);
  341.       $updated = array_map([self::class, 'RemoveAC'], array_filter($mds, fn ($x) => 'update' == $x['ac'] || 'create' == $x['ac']));
  342.       if ($params['updateProgress'] ?? false) {
  343.         $params['updateProgress'](['status' => "update $module"]);
  344.       }
  345.       $update_count = count($updated);
  346.       if ($update_count > 0) {
  347.         $collection = $dm->getDocumentCollection($model);
  348.         $updates = array_chunk($updated, $count);
  349.         foreach ($updates as $update) {
  350.           $end = count($update);
  351.           $d_updates = array_map(function ($x) {
  352.             return [
  353.               'updateOne' => [
  354.                 ['_id' => $x['_id']],
  355.                 ['$set' => $x],
  356.                 ['upsert' => true],
  357.               ],
  358.             ];
  359.           }, $update);
  360.           $collection->bulkWrite($d_updates);
  361.           $inserted += $end;
  362.           if ($params['updateProgress'] ?? false) {
  363.             $params['updateProgress'](['progress' => $inserted / $total * 100]);
  364.           }
  365.         }
  366.         if ($params['updateProgress'] ?? false) {
  367.           $params['updateProgress'](['progress' => $inserted / $total * 100]);
  368.         }
  369.       }
  370.       $updatedMany = array_map([self::class, 'RemoveAC'], array_filter($mds, fn ($x) => 'update_many' == $x['ac']));
  371.       $update_count = count($updatedMany);
  372.       if ($update_count > 0) {
  373.         $collection = $dm->getDocumentCollection($model);
  374.         $updatesMany = array_chunk($updatedMany, $count);
  375.         foreach ($updatesMany as $updateMany) {
  376.           $end = count($updateMany);
  377.           $d_updates = array_map(function ($x) {
  378.             $op = $x['op'] ?? '$set';
  380.             return [
  381.               'updateMany' => [
  382.                 $x['filter'],
  383.                 [[$op => $x['update']]],
  384.               ],
  385.             ];
  386.           }, $updateMany);
  387.           $res = $collection->bulkWrite($d_updates);
  388.           $inserted += $end;
  389.           if ($params['updateProgress'] ?? false) {
  390.             $params['updateProgress'](['progress' => $inserted / $total * 100]);
  391.           }
  392.         }
  393.         if ($params['updateProgress'] ?? false) {
  394.           $params['updateProgress'](['progress' => $inserted / $total * 100]);
  395.         }
  396.       }
  397.     }
  398.   }
  399.   public static function updateOne($dm, $module, $setting)
  400.   {
  401.     ['where' => $where, 'update' => $update] = $setting;
  402.     $model = Helpers::get_module($module);
  403.     $collection = $dm->getDocumentCollection($model);
  404.     $collection->updateOne(
  405.       $where,
  406.       $update,
  407.       ['upsert' => true]
  408.     );
  409.   }
  410.   public static function updateMany($dm, $module, $setting)
  411.   {
  412.     ['where' => $where, 'update' => $update] = $setting;
  413.     $model = Helpers::get_module($module);
  414.     $collection = $dm->getDocumentCollection($model);
  415.     $res = $collection->updateMany(
  416.       $where,
  417.       $update
  418.     );
  419.     return ['matched'=>$res->getMatchedCount(), 'modified'=>$res->getModifiedCount()];
  420.   }
  421.   public static function getOneBy($dm, $model, $where)
  422.   {
  423.     $md = Helpers::get_module($model);
  425.     return $dm->getRepository($md)->findOneBy($where);
  426.   }
  428.   public static function getList($dm, $model, $where)
  429.   {
  430.     $md = Helpers::get_module($model);
  432.     return $dm->getRepository($md)->findBy($where);
  433.   }
  435.   public static function AddArray($dm, $serializer, $model, $arr)
  436.   {
  437.     $values = $serializer->deserialize(json_encode($arr), $model.'[]', 'json');
  438.     $ids = [];
  439.     foreach ($values as $key => $value) {
  440.       // code...
  441.       $dm->persist($value);
  442.       $dm->flush();
  443.       $ids[$key] = $value->getId();
  444.     }
  446.     return $dm->getRepository($model)->findBy(['id' => ['$in' => $ids]]);
  447.   }
  449.   public static function ModelCount($dm, $module, $where)
  450.   {
  451.     $m_model = strtolower($module);
  452.     $model = Helpers::get_module($m_model);
  453.     if ($model) {
  454.       $qb = $dm->createQueryBuilder($model);
  455.       if ($where) {
  456.         $qb = $qb->addAnd($where);
  457.       }
  459.       return $qb->getQuery()->execute()->count();
  460.     }
  461.   }
  463.   public static function MultiDeleteModule($dm, $module, $where)
  464.   {
  465.     $m_model = strtolower($module);
  466.     $model = Helpers::get_module($m_model);
  467.     if ($model) {
  468.       $qb = $dm->createQueryBuilder($model);
  469.       $qb = $qb->remove();
  470.       if ($where) {
  471.         $qb = $qb->addAnd($where);
  472.       }
  473.       $qb->getQuery()->execute();
  474.       $dm->clear();
  476.       return true;
  477.     }
  478.   }
  479. }