yager-api/commands/EventoController.php

<?php

namespace app\commands;

use app\components\FirebaseHelper;
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\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 (!$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])) {
              $modelGrupo = Grupo::findOne(['firebaseId' => $usuarioRef["grupos"][0]]);
              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])) {
              foreach ($usuarioRef["dependencias"] as $dependencia) {
                $dependenciaModel = Dependencia::findOne(["firebaseId" => $dependencia]);
                if ($dependenciaModel === null) {
                  $dependenciaRef = $dependencias[$dependencia];
                  $dependenciaModel = new Dependencia();

                  $dependenciaModel->firebaseId = $dependencia;
                  $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" => null],
              // ["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);
  }
}