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 = 1; // 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) {
        $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"];
          $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;
          }

          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;
              }
            }
          }

          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 = $usuarios[$usuarioEvento["uid"]];

            // Usuarios
            if ($usuarioModelo === null && isset($usuarios[$usuarioEvento["uid"]])) {
              $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()));
              }
            }

            // Grupos
            if ($usuarioModelo !== null && isset($usuarioRef["grupos"]) && isset($usuarioRef["grupos"][0])) {
              $modelGrupo = Grupo::findOne(['firebaseId' => $usuarioRef["grupos"][0]]);
              $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"];
              for ($i = 0; $i < count($resultados); $i++) {
                $res = count($resultados[$usuarioModelo->uid]);
                if ($res > 0) {
                  foreach($resultados[$usuarioModelo->uid] as $acciones) {
                    if (isset($acciones) && isset($acciones[0])){
                      $resultadoModelo = Resultado::find()
                        ->andWhere([
                          "idUsuario" => $usuarioModelo->id,
                          "idEvento" => $modelo->id,
                          "accion" => $acciones
                        ])
                        ->one();
                      
                      if ($resultadoModelo === null) {
                        $resultadoModelo = new Resultado();

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

                        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->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);
  }

}