yager-api/commands/EventoController.php

<?php

namespace app\commands;

use app\components\FirebaseHelper;
use app\models\Notificacion;
use app\models\NotificacionUsuario;
use common\data\Respuesta;
use v1\models\Dependencia;
use v1\models\Evento;
use v1\models\EventoAccion;
use v1\models\EventoGrupo;
use v1\models\Grupo;
use v1\models\Red;
use v1\models\Resultado;
use v1\models\Usuario;
use v1\models\UsuarioDependencia;
use v1\models\UsuarioGrupo;
use yii\console\Controller;
use yii\db\Expression;
use yii\db\Query;
use yii\helpers\Json;

class EventoController extends Controller {

  public function stdoutln($cadena) {
    return $this->stdout($cadena . "\n");
  }

  public function cambiarFecha($string) {
    $formato = "D M d Y H:i:s P";
    $fecha = \DateTime::createFromFormat($formato, $string);

    return $fecha;
  }

  public function actionSincronizar() {
    $firebase = new FirebaseHelper();
    $firestore = $firebase->firestore();

    $refGrupos = $firestore->collection("grupos");
    $refUsuarios = $firestore->collection("usuarios");
    $refDependencias = $firestore->collection("dependencias");

    $grupos = [];
    $usuarios = [];
    $dependencias = [];

    foreach ($refGrupos->documents() as $grupo) {
      $grupos[$grupo->id()] = $grupo->data();
    }

    foreach ($refUsuarios->documents() as $usuario) {
      $usuarios[$usuario->id()] = $usuario->data();
    }

    foreach ($refDependencias->documents() as $dependencia) {
      $dependencias[$dependencia->id()] = $dependencia->data();
    }

    $ultimaFecha = null;
    $limite = 100; // 1000;
    $continuar = true;
    do {
      $this->stdout("Sincronizando ...");
      $ref = $firestore->collection("eventos")
        ->where("sincronizado", "==", null)
        ->orderBy("timestamp", "ASC")
        ->limit($limite);

      if ($ultimaFecha !== null) {
        $ref = $ref->startAt([$ultimaFecha]);
      }

      $c = 0; # Contador de registros procesados
      foreach ($ref->documents() as $doc) {
        $this->stdoutln($doc->id());
        $c++;
        $data = $doc->data();
        $ultimaFecha = $data["timestamp"];
        $modelo = Evento::findOne(["firebaseId" => $doc->id()]);
        if ($modelo === null) {
          $modelo = new Evento();
        }
        try {

          $modelo->nombre = $data["nombre"];
          $modelo->descripcion = $data["descripcion"];
          $modelo->ciudad = $data["ciudad"];
          $modelo->redSocial = $data["redSocial"];
          $creado = \DateTime::createFromFormat('Y-m-d\TH:i:s.u\Z', $data["timestamp"]);
          if ($creado !== false) {
            $modelo->creado = $creado->format(\DateTime::RFC3339_EXTENDED);
          }
          $fechaInicio = $this->cambiarFecha($data["fechaInicio"]);
          if ($fechaInicio !== false) {
            $modelo->fechaInicio = $fechaInicio->format(\DateTime::RFC3339_EXTENDED);
          }
          $fechaFinal = $this->cambiarFecha($data["fechaFinal"]);
          if ($fechaFinal !== false) {
            $modelo->fechaFinal = $fechaFinal->format(\DateTime::RFC3339_EXTENDED);
          }
          $modelo->fotoEvento = $data["fotoEvento"];
          $modelo->url = $data["pathFirebase"];
          if (isset($data["tag"])) {
            $modelo->tag = $data["tag"];
          }
          $modelo->firebaseId = $doc->id();

          if (!$modelo->save()) {
            $this->stdoutln('Ocurrió un error al guardar un evento. ' . Json::encode($modelo->getFirstErrors()));
            continue;
          }

          if (isset($data["redes"])) {
            foreach ($data["redes"] as $red) {
              $eventoRed = Red::find()
                ->andWhere([
                  "idEvento" => $modelo->id,
                  "url" => $red["url"]
                ])
                ->one();

              if ($eventoRed === null) {
                $eventoRed = new Red();

                $eventoRed->idEvento = $modelo->id;
                $eventoRed->key = $red["key"];
                $eventoRed->url = $red["url"];
                $eventoRed->redSocial = $red["redSocial"];

                if (!$eventoRed->save()) {
                  $this->stdoutln('Ocurrió un error al guardar una red. ' . Json::encode($eventoRed->getFirstErrors()));
                  continue;
                }
              }
            }
          }

          foreach ($data["accion"] as $accion) {
            $eventoAccion = EventoAccion::find()
              ->andWhere([
                "idEvento" => $modelo->id,
                "accion" => $accion
              ])
              ->one();

            if ($eventoAccion === null) {
              $eventoAccion = new EventoAccion();

              $eventoAccion->idEvento = $modelo->id;
              $eventoAccion->accion = $accion;

              if (!$eventoAccion->save()) {
                $this->stdoutln('Ocurrió un error al guardar un evento-accion. ' . Json::encode($eventoAccion->getFirstErrors()));
                continue;
              }
            }
          }

          //Grupos dentro de los eventos
          foreach ($data["grupos"] as $grupoEvento) {
            $grupoModelo = Grupo::findOne(["firebaseId" => $grupoEvento]);
            if ($grupoModelo === null && isset($grupos[$grupoEvento])) {
              $grupoModelo = new Grupo();
              $grupoModelo->creado = new Expression('now()');
              $grupoModelo->nombre = $grupos[$grupoEvento]["nombre"];
              $grupoModelo->descripcion = $grupos[$grupoEvento]["descripcion"];
              $grupoModelo->firebaseId = $grupoEvento;

              if (!$grupoModelo->save()) {
                $this->stdoutln('Ocurrió un error al guardar un grupo. ' . Json::encode($grupoModelo->getFirstErrors()));
              }
            }
            if ($grupoModelo !== null) {
              $eventoGrupo = EventoGrupo::find()
                ->andWhere([
                  "idEvento" => $modelo->id,
                  "idGrupo" => $grupoModelo->id
                ])
                ->one();

              if ($eventoGrupo === null) {
                $eventoGrupo = new EventoGrupo();

                $eventoGrupo->idEvento = $modelo->id;
                $eventoGrupo->idGrupo = $grupoModelo->id;

                if (!$eventoGrupo->save()) {
                  $this->stdoutln('Ocurrió un error al guardar un evento-grupo. ' . Json::encode($eventoGrupo->getFirstErrors()));
                }
              }
            }
          }

          foreach ($data["usuarios"] as $usuarioEvento) {
            $usuarioModelo = Usuario::findOne(["uid" => $usuarioEvento["uid"]]);
            $usuarioRef = isset($usuarios[$usuarioEvento["uid"]])
              ? $usuarios[$usuarioEvento["uid"]] : null;

            // Usuarios
            if ($usuarioModelo === null && $usuarioRef !== null) {
              $usuarioModelo = new Usuario();
              $usuarioModelo->uid = $usuarioRef["uid"];
              $usuarioModelo->nombre = $usuarioRef["nombre"];
              if (isset($usuarioRef["email"])) {
                $usuarioModelo->email = $usuarioRef["email"];
              }
              $usuarioModelo->telefono = $usuarioRef["telefono"];
              $usuarioModelo->facebook = $usuarioRef["facebook"];
              if (isset($usuarioRef["facebookVerificado"])) {
                $usuarioModelo->facebookVerificado = $usuarioRef["facebookVerificado"];
              }
              $usuarioModelo->instagram = $usuarioRef["instagram"];
              if (isset($usuarioRef["instagramVerificado"])) {
                $usuarioModelo->instagramVerificado = $usuarioRef["instagramVerificado"];
              }
              $usuarioModelo->twitter = $usuarioRef["twitter"];
              if (isset($usuarioRef["twitterVerificado"])) {
                $usuarioModelo->twitterVerificado = $usuarioRef["twitterVerificado"];
              }
              $usuarioModelo->genero = $usuarioRef["genero"];
              $usuarioModelo->verificado = $usuarioRef["verificado"];
              $usuarioModelo->creado = new Expression('now()');
              if ($usuarioRef["estatus"] === false) {
                $usuarioModelo->eliminado = new Expression('now()');
              }

              if (!$usuarioModelo->save()) {
                $this->stdoutln('Ocurrió un error al guardar un usuario. ' . Json::encode($usuarioModelo->getFirstErrors()));
              }
            }

            // UsuarioGrupo
            if ($usuarioModelo !== null && isset($usuarioRef["grupos"]) && isset($usuarioRef["grupos"][0])) {
              for($i = 0; $i < count($usuarioRef["grupos"]); $i++) {
                $modelGrupo = Grupo::findOne(['firebaseId' => $usuarioRef["grupos"][$i]]);
                if (isset($modelGrupo)) {
                  $usuarioGrupo = UsuarioGrupo::find()
                    ->andWhere([
                      "idUsuario" => $usuarioModelo->id,
                      "idGrupo" => $modelGrupo->id
                    ])
                    ->one();

                  if ($usuarioGrupo === null) {
                    $usuarioGrupo = new UsuarioGrupo();

                    $usuarioGrupo->idUsuario = $usuarioModelo->id;
                    $usuarioGrupo->idGrupo = $modelGrupo->id;

                    if (!$usuarioGrupo->save()) {
                      $this->stdoutln('Ocurrió un error al guardar un usuario-grupo. ' . Json::encode($usuarioGrupo->getFirstErrors()));
                    }
                  }
                }
              }
            }

            // Resultados
            if ($usuarioModelo !== null && isset($data["resultado"])) {
              $resultados = $data["resultado"];
              if (isset($resultados[$usuarioModelo->uid])) {
                foreach ($resultados[$usuarioModelo->uid] as $_accion) {
                  $resultadoModelo = Resultado::find()
                    ->andWhere([
                      "idUsuario" => $usuarioModelo->id,
                      "idEvento" => $modelo->id,
                      "accion" => $_accion
                    ])
                    ->exists();

                  if (!$resultadoModelo) {
                    $resultadoModelo = new Resultado();

                    $resultadoModelo->idUsuario = $usuarioModelo->id;
                    $resultadoModelo->idEvento = $modelo->id;
                    $resultadoModelo->accion = $_accion;

                    if (!$resultadoModelo->save()) {
                      $this->stdoutln('Ocurrió un error al guardar un resultado. ' . Json::encode($resultadoModelo->getFirstErrors()));
                    }
                  }
                }
              }
            }

            // Dependencias
            if ($usuarioModelo !== null && isset($usuarioRef["dependencias"]) && isset($usuarioRef["dependencias"][0])) {
              if (!empty($usuarioRef["dependencias"])){
                if (is_array($usuarioRef["dependencias"])) {
                  for ($i = 0; $i < count($usuarioRef["dependencias"]); $i++){
                    $dependenciaModel = Dependencia::findOne(["firebaseId" => $usuarioRef["dependencias"][$i]]);
                    if ($dependenciaModel === null) {
                      $dependenciaRef = $dependencias[$usuarioRef["dependencias"][$i]];
                      $dependenciaModel = new Dependencia();
    
                      $dependenciaModel->firebaseId = $usuarioRef["dependencias"][$i];
                      $dependenciaModel->nombre = $dependenciaRef['nombre'];
                      $dependenciaModel->descripcion = $dependenciaRef['descripcion'];
                      $dependenciaModel->estatus = $dependenciaRef['estatus'];
    
                      $creado = \DateTime::createFromFormat('Y-m-d\TH:i:s.u\Z', $dependenciaRef["timestamp"]);
                      if ($creado !== false) {
                        $dependenciaModel->creado = $creado->format(\DateTime::RFC3339_EXTENDED);
                      }
    
                      if (!$dependenciaModel->save()) {
                        $this->stdoutln('Ocurrió un error al guardar una dependencia. ' . Json::encode($dependenciaModel->getFirstErrors()));
                      }
                    }
    
                    //UsuarioDependencia
                    $usuarioDependencia = UsuarioDependencia::find()
                      ->andWhere([
                        "idUsuario" => $usuarioModelo->id,
                        "idDependencia" => $dependenciaModel->id
                      ])
                      ->one();
    
                    if ($usuarioDependencia === null) {
                      $usuarioDependencia = new UsuarioDependencia();
    
                      $usuarioDependencia->idUsuario = $usuarioModelo->id;
                      $usuarioDependencia->idDependencia = $dependenciaModel->id;
    
                      if (!$usuarioDependencia->save()) {
                        $this->stdoutln('Ocurrió un error al guardar un usuario-dependencia. ' . Json::encode($usuarioDependencia->getFirstErrors()));
                      }
                    }
                  }
                } else {
                  $dependenciaModel = Dependencia::findOne(["firebaseId" => $usuarioRef["dependencias"]]);
                    if ($dependenciaModel === null) {
                      $dependenciaRef = $dependencias[$usuarioRef["dependencias"]];
                      $dependenciaModel = new Dependencia();
    
                      $dependenciaModel->firebaseId = $usuarioRef["dependencias"];
                      $dependenciaModel->nombre = $dependenciaRef['nombre'];
                      $dependenciaModel->descripcion = $dependenciaRef['descripcion'];
                      $dependenciaModel->estatus = $dependenciaRef['estatus'];
    
                      $creado = \DateTime::createFromFormat('Y-m-d\TH:i:s.u\Z', $dependenciaRef["timestamp"]);
                      if ($creado !== false) {
                        $dependenciaModel->creado = $creado->format(\DateTime::RFC3339_EXTENDED);
                      }
    
                      if (!$dependenciaModel->save()) {
                        $this->stdoutln('Ocurrió un error al guardar una dependencia. ' . Json::encode($dependenciaModel->getFirstErrors()));
                      }
                    }
    
                    //UsuarioDependencia
                    $usuarioDependencia = UsuarioDependencia::find()
                      ->andWhere([
                        "idUsuario" => $usuarioModelo->id,
                        "idDependencia" => $dependenciaModel->id
                      ])
                      ->one();
    
                    if ($usuarioDependencia === null) {
                      $usuarioDependencia = new UsuarioDependencia();
    
                      $usuarioDependencia->idUsuario = $usuarioModelo->id;
                      $usuarioDependencia->idDependencia = $dependenciaModel->id;
    
                      if (!$usuarioDependencia->save()) {
                        $this->stdoutln('Ocurrió un error al guardar un usuario-dependencia. ' . Json::encode($usuarioDependencia->getFirstErrors()));
                      }
                    }
                }
              }
            }
          }

          $hoy = new \DateTime();
          $doc->reference()
            ->update([
              ["path" => "sincronizado", "value" => "OK"],
              ["path" => "sincronizadoFecha", "value" => $hoy->format("Y-m-d H:i:s")],
            ]);
          $this->stdoutln("Sincronizado correcto");
        } catch (\Exception $e) {
          $this->stdoutln("Exception: {$e->getMessage()}\n");
          $doc->reference()
            ->update([
              ["path" => "sincronizado", "value" => "ERROR"],
              ["path" => "sincronizadoError", "value" => $e->getMessage()],
              ["path" => "sincronizadoErrorLine", "value" => $e->getLine()],
            ]);
        }
      }

      # Si los registros procesados son menores al límite, terminar
      if ($c < $limite) {
        $continuar = false;
      }
    } while ($continuar);
  }

  public function consultarNorificacion() {

    $query = Notificacion::find()
      ->orderBy(["id" => SORT_ASC]);

    $enviando = (clone $query)
      ->andWhere(["estatus" => Notificacion::ESTATUS_ENVIANDO])
      ->one();
    
    if ($enviando !== null) {
      $this->stdout("Notificación en poceso: ". $enviando->id ."\n");
      return null;
    }

    return (clone $query)
      ->andWhere(["estatus" => Notificacion::ESTATUS_NUEVO])
      ->one();
  }

  public function actionParticipacion() {

    $eventos = (new Query())
      ->select([
        "nombre",
        "tag"
      ])
      ->from("Evento")
      ->andWhere([">=", "fechaFinal", new Expression("now()-interval '7 days'")])
      ->groupBy(["tag", "nombre"])
      ->indexBy("tag")
      ->column();
    
      // $sql = $eventos->createCommand()->getRawSql();

      $query2 = (new Query())
        ->select([
          "tag",
          "{{Usuario}}.id",
          "{{Usuario}}.nombre",
          "{{Usuario}}.telefono",
          "case when count({{Resultado}}.accion) > 0 then true else false end as [[Participo]]"
        ])
        ->from("Evento")
        ->innerJoin("EventoGrupo", "{{EventoGrupo}}.[[idEvento]] = {{Evento}}.id")
        ->innerJoin("Grupo", "{{Grupo}}.id = {{EventoGrupo}}.[[idGrupo]]")
        ->innerJoin("UsuarioGrupo", "{{UsuarioGrupo}}.[[idGrupo]] = {{Grupo}}.id")
        ->innerJoin("Usuario", "{{Usuario}}.[[id]] = {{UsuarioGrupo}}.[[idUsuario]]")
        ->innerJoin("UsuarioDependencia", "{{UsuarioDependencia}}.[[idUsuario]] = {{Usuario}}.id")
        ->leftJoin("Resultado", "{{Resultado}}.[[idEvento]] = {{Evento}}.id and {{Resultado}}.[[idUsuario]] = {{Usuario}}.id")
        ->andWhere(["{{Usuario}}.eliminado" => null])
        ->andWhere([">=", "fechaFinal", new Expression("now()-interval '7 days'")])
        /* ->andWhere([
          "AND",
          [">=", "fechaFinal", $desde],
          ["<=", "fechaFinal", $hasta]
        ]) */
        ->groupBy([
          "{{Usuario}}.nombre",
          "{{Usuario}}.telefono",
          "{{Usuario}}.id",
          "tag"
        ])
        ->orderBy([
          "{{Usuario}}.id" => SORT_ASC,
          // "tag" => SORT_ASC,
          "[[Participo]]" => SORT_DESC,
        ]);

        $aux = [];

        foreach($query2->each() as $consulta) {
          if (!isset($aux[$consulta['id']])) {
            $aux[$consulta['id']] = [
              "nombreUsuario" => $consulta['nombre'],
              "telefono" => $consulta['telefono'],
              "id" => $consulta['id'],
              "eventosFaltantes" => [],
              "eventosParticipo" => []
            ];
          }
          $nombreEvento = $eventos[$consulta['tag']];
          if ($consulta['Participo']) {
            $aux[$consulta['id']]['eventosParticipo'][] = $nombreEvento;
          } else {
            $aux[$consulta['id']]['eventosFaltantes'][] = $nombreEvento;
          }
        }

        $notificacion = new Notificacion();
        $notificacion->creado = new Expression("now()");

        if (!$notificacion->save()) {
          return (new Respuesta($notificacion))
            ->mensaje("Hubo un problema al generar la notificación");
        }
        $notificacion->refresh();

        foreach ($aux as $usuario) {
          $notificacionUsuario = new NotificacionUsuario();
          
          $notificacionUsuario->idNotificacion = $notificacion->id;
          $notificacionUsuario->idUsuario = $usuario['id'];
          $notificacionUsuario->nombre = $usuario['nombreUsuario'];
          $notificacionUsuario->telefono = $usuario['telefono'];
          $notificacionUsuario->parametros = [
            [
              "type" => "text",
              "text" => count($usuario["eventosParticipo"])."/".count($eventos)
            ],
            [
              "type" => "text",
              "text" => "gracias por tu"
            ]
          ];

          if (!$notificacionUsuario->save()) {
            return (new Respuesta($notificacionUsuario))
              ->mensaje("Hubo un problema al generar la notificación");
          }
        }

        $notificacion->estatus = Notificacion::ESTATUS_NUEVO;

        $notificacion->save();

        $this->stdout("Terminó");
    // $this->stdout(json_encode($aux)."\n");
    // file_put_contents("archivo.json", json_encode($aux));
  }
}