Untitled

mail@pastecode.io avatar
unknown
plain_text
a year ago
22 kB
0
Indexable
Never
<?php

namespace App\Http\Controllers;

use App\Models\AsistenciaRegistros;
use App\Models\EventosRegistros;
use App\Models\TiposDeRegistros;
use App\Models\UsuarioConteos;
use App\Models\UsuarioPremios;
use App\Models\UsuarioRegistros;
use DateTime;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

date_default_timezone_set('America/Mexico_City');

class UsuarioRegistrosController extends Controller
{

    public function lista_api(Request $request){
        if($request->ajax()){
            return datatables()->eloquent(UsuarioRegistros::query()->where('users_id', '=', Auth::user()->id)->with('EventosRegistros', 'EventosRegistros.Eventos' ,'TiposDeRegistros')->orderBy('created_at', 'desc'))
            ->addColumn('Fecha', function ($row) {

                $Fecha = $row->created_at;

                return $Fecha;
            })
            ->addColumn('estado', function ($row) {

                if($row->habilitado == 0){
                    $estado = '<span class="badge bg-primary">Registrado</span>';
                }else{
                    $estado = '<span class="badge bg-danger">Cancelado</span>';
                }

                return $estado;
            })
            ->addColumn('btn', function ($row) {

                if($row->habilitado == 0){

                    $FechaHoraActual = NOW();

                    if($row->EventosRegistros->fechaHoraEditar < $FechaHoraActual){
                        $actionBtn = "-";
                    }else{
                        $actionBtn = "<div class='btn-group btn-group-sm' role='group'>";
                        $actionBtn = $actionBtn . "<a href='" . route('mis_actividades.desactivar', ['idUsuarioRegistros' => $row->id]) . "' class='btn btn-danger'>Desvincular</a>";
                        $actionBtn = $actionBtn . "</div>";
                    }

                }else{
                    $actionBtn = "-";
                }

                return $actionBtn;
            })
            ->rawColumns(['btn', 'Fecha', 'estado'])
            ->toJson();
        }

        return redirect()->route('mis_actividades.lista');
    }

    public function lista(){
        return view('misActividades.lista-historial');
    }

    public function activas_api(Request $request){
        if($request->ajax()){
            return datatables()
            ->eloquent(UsuarioRegistros::query()
            ->where('users_id', '=', Auth::user()->id)
            ->with('EventosRegistros', 'EventosRegistros.Eventos' ,'TiposDeRegistros')
            ->join('eventos_registros', 'eventos_registros.id', '=', 'usuario_registros.eventos_registros_id')
            ->join('tipos_de_registros', 'tipos_de_registros.id', '=', 'usuario_registros.tipos_de_registros_id')
            ->join('eventos', 'eventos.id', '=', 'eventos_registros.eventos_id')
            ->where('eventos_registros.habilitado', '=', 0)
            ->where('usuario_registros.habilitado', '=', 0)
            ->select('usuario_registros.id as idRegistros',
                     'usuario_registros.created_at as FechaRegistro',
                     'usuario_registros.habilitado as HabilitadoRegistro',
                     'eventos_registros.fechaHoraEditar as FechaHoraEditar',
                     'eventos_registros.nombre as NombreActividad',
                     'eventos_registros.descripcion as DescripcionActividad',
                     'tipos_de_registros.nombre as NombreCategoria',
                     'eventos.nombre as NombreEvento'))

            ->addColumn('Fecha', function ($row) {

                $Fecha = $row->FechaRegistro;

                return $Fecha;
            })
            ->addColumn('estado', function ($row) {

                if($row->HabilitadoRegistro == 0){
                    $estado = '<span class="badge bg-primary">Registrado</span>';
                }else{
                    $estado = '<span class="badge bg-danger">Cancelado</span>';
                }

                return $estado;
            })
            ->addColumn('btn', function ($row) {

                if($row->HabilitadoRegistro == 0){

                    $FechaHoraActual = NOW();

                    if($row->FechaHoraEditar < $FechaHoraActual){
                        $actionBtn = "-";
                    }else{
                        $actionBtn = "<div class='btn-group btn-group-sm' role='group'>";
                        $actionBtn = $actionBtn . "<a href='" . route('mis_actividades.desactivar', ['idUsuarioRegistros' => $row->idRegistros]) . "' class='btn btn-danger'>Desvincular</a>";
                        $actionBtn = $actionBtn . "</div>";
                    }

                }else{
                    $actionBtn = "-";
                }

                return $actionBtn;
            })
            ->rawColumns(['btn', 'Fecha', 'estado'])
            ->toJson();
        }

        return redirect()->route('mis_actividades.lista');
    }

    public function activas(){
        return view('misActividades.activas');
    }

    public function asistencias_api(Request $request){
        if($request->ajax()){
            return datatables()
            ->eloquent(AsistenciaRegistros::query()
            ->with('TiposDeRegistros', 'EventosRegistros', 'EventosRegistros.Eventos')
            ->where('users_id', '=', Auth::user()->id))
            ->addColumn('Fecha', function ($row) {

                $Fecha = $row->created_at;
                return $Fecha;
            })

            ->addColumn('BtnCancelar', function ($row) {
                if( $row->habilitado == 1){
                    $actionBtn = '<span class="badge bg-danger">Cancelado</span>';
                }else{
                    $actionBtn = '<span class="badge bg-primary">Activo</span>';
                }

                return $actionBtn;
            })

            ->rawColumns(['Fecha', 'BtnCancelar'])
            ->toJson();
        }

        return redirect()->route('asistencias.lista');
    }

    public function asistencias(){
        return view('misActividades.asistencias');
    }

    public function premios_api(Request $request){
        if($request->ajax()){
            return datatables()
            ->eloquent(UsuarioPremios::query()
            ->with('TiendaVinculos', 'TiendaVinculos.TiendaPremios', 'TiendaVinculos.TiendaCategorias')
            ->where('users_id', '=', Auth::user()->id))

            ->addColumn('Gachapon', function ($row) {
                $Garchapon = $row->TiendaVinculos->TiendaCategorias->nombre;
                return $Garchapon;
            })

            ->addColumn('Premio', function ($row) {
                $Premio = $row->TiendaVinculos->TiendaPremios->nombre;
                return $Premio;
            })

            ->addColumn('Puntos', function ($row) {
                $Puntos = $row->TiendaVinculos->TiendaCategorias->puntos;
                return $Puntos;
            })

            ->addColumn('Fecha', function ($row) {
                $Fecha = $row->created_at;
                return $Fecha;
            })

            ->addColumn('Estado', function ($row) {
                if( $row->finalizar == 1){
                    $actionBtn = '<span class="badge bg-info">Finalizado</span>';
                }else{
                    $actionBtn = '<span class="badge bg-primary">Pendiente</span>';
                }

                return $actionBtn;
            })

            ->rawColumns(['Estado'])
            ->toJson();
        }

        return redirect()->route('mis_actividades.premios');
    }

    public function premios(){
        return view('misActividades.lista-premios');
    }

    public function lista_api_actividades(int $idTipoDeCategorias){
        $ValidarTipoDeRegistros = TiposDeRegistros::find($idTipoDeCategorias);

        if(!$ValidarTipoDeRegistros || $ValidarTipoDeRegistros->filtroUsuario == 1){
            return response(404)->header('Content-type', 'text/plain');
        }

        $ListaDeActividades = EventosRegistros::where('habilitado', '=', 0)
                                                ->where('tipos_de_registros_id', '=', $idTipoDeCategorias)
                                                ->get();

        return response(json_encode($ListaDeActividades), 200)->header('Content-type', 'text/plain');
    }

    public function nuevo(){
        $info['ListaCategorias'] = TiposDeRegistros::where('habilitado', '=', 0)->where('filtroUsuario', '=', 0)->orderBy('nombre', 'ASC')->get();
        return view('misActividades.crear', $info);
    }
    /*
    public function ValidarHorarioDeActividad($usuario_id, $actividad_id, $fechaHoraInicio, $fechaHoraFinal) {
        // Obtener todas las actividades de eventos_registros del usuario con id $usuario_id
        //$actividades = $this->where('usuario_id', $usuario_id)->where('montable', 1)->get();
        $actividades = EventosRegistros::where('montable',1)->where('id',$actividad_id)->get();
        error_log($fechaHoraInicio);
        foreach ($actividades as $actividad) {
            // Si la actividad a validar es diferente a la que se está evaluando en el ciclo
            // y los rangos de tiempo se superponen, entonces la validación falla.
            if ($actividad->id != $actividad_id &&
                ($fechaHoraInicio >= $actividad->fechaHoraInicio && $fechaHoraInicio < $actividad->fechaHoraFinal ||
                $fechaHoraFinal > $actividad->fechaHoraInicio && $fechaHoraFinal <= $actividad->fechaHoraFinal ||
                $actividad->fechaHoraInicio >= $fechaHoraInicio && $actividad->fechaHoraInicio < $fechaHoraFinal ||
                $actividad->fechaHoraFinal > $fechaHoraInicio && $actividad->fechaHoraFinal <= $fechaHoraFinal)) {
                    return false;
            }
        }

        return true;
    }
    */
    /*
    public function validarRegistroActividad($usuario_id, $actividad_id, $fechaHoraInicio, $fechaHoraFinal)
    {

    if ($actividad->montable == 1) {
        // Verificar si la fecha y hora de la actividad a registrar se superpone con alguna actividad en la que el usuario se haya registrado previamente
        $usuario_actividades = UsuarioRegistros::where('users_id', $usuario_id)
        ->pluck('eventos_registros_id')
        ->toArray();

        $actividades_superpuestas = EventosRegistros::whereIn('id', $usuario_actividades)
        ->where('montable', 1)
        ->where('id', '!=', $actividad_id)
        ->where(function ($query) use ($fechaHoraInicio, $fechaHoraFinal) {
            $query->where(function ($query) use ($fechaHoraInicio, $fechaHoraFinal) {
                $query->where('fechaHoraInicio', '>=', $fechaHoraInicio)
                    ->where('fechaHoraInicio', '<', $fechaHoraFinal);
            })->orWhere(function ($query) use ($fechaHoraInicio, $fechaHoraFinal) {
                $query->where('fechaHoraFinal', '>', $fechaHoraInicio)
                    ->where('fechaHoraFinal', '<=', $fechaHoraFinal);
            })->orWhere(function ($query) use ($fechaHoraInicio, $fechaHoraFinal) {
                $query->where('fechaHoraInicio', '<=', $fechaHoraInicio)
                    ->where('fechaHoraFinal', '>', $fechaHoraInicio);
            })->orWhere(function ($query) use ($fechaHoraInicio, $fechaHoraFinal) {
                $query->where('fechaHoraInicio', '>=', $fechaHoraInicio)
                    ->where('fechaHoraFinal', '<=', $fechaHoraFinal);
            });
        })->get();

        if ($actividades_superpuestas->isNotEmpty()) {
            return false;
        }

    }
    return true;
    }
    */



    public function nuevo_post(Request $request){

        $request->validate([
            'TipoDeActividad' => 'required|numeric',
            'Actividad' => 'required|numeric',
        ], [
            'TipoDeActividad.required' => 'La categoría de actividad es requerida.',
            'TipoDeActividad.numeric' => 'La categoría de actividad tiene un dato no válido.',
            'Actividad.required' => 'La actividad es requerida.',
            'Actividad.numeric' => 'La actividad tiene un dato no válido.',
        ]);

        $ValidarTipoDeActividad = TiposDeRegistros::find($request->TipoDeActividad);
        $ValidarActividad = EventosRegistros::find($request->Actividad);

        if( !$ValidarTipoDeActividad ){
            return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'Categoría de actividad inválida.');
        }else if( $ValidarTipoDeActividad->habilitado == 1 ){
            return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'Categoría de actividad está desactivada y no puede utilizarse.');
        }else if ( $ValidarTipoDeActividad->filtroUsuario == 1 ){
            return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'Categoría de actividad no está disponible para usuarios.');
        }

        if( !$ValidarActividad ){
            return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'Actividad inválida.');
        }else if( $ValidarActividad->habilitado == 1 ){
            return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'Está actividad está desactivada y no puede utilizarse.');
        }else if ( ($ValidarActividad->maxUsuarios <= $ValidarActividad->vinculosActuales) && $ValidarActividad->maxUsuarios != "-1" ){
            return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'La actividad se encuentra llena y no permite más registros.');
        }

        $actividad = EventosRegistros::find($request->Actividad);
        $fechaHoraInicio = $actividad->horario_inicio;
        $fechaHoraFinal = $actividad->horario_fin;
        $actividad_id = $ValidarActividad->id;

        //($usuario_id, $actividad_id, $fechaHoraInicio, $fechaHoraFinal)

        $usuario_id = Auth::id(); // o el ID del usuario que estés validando
        //dd($usuario_id);
        //$ValidarHorarioUsuario = $this->ValidarHorarioDeActividad($usuario_id, $actividad_id, $horario_inicio, $horario_fin);

        //Verificar si la actividad es de inscripción libre (montable = 0) o restringida por horario (montable = 1)
        if ($actividad->montable == 1) {
            // Verificar si la fecha y hora de la actividad a registrar se superpone con alguna actividad en la que el usuario se haya registrado previamente
            $usuario_actividades = UsuarioRegistros::where('users_id', $usuario_id)
                ->where('habilitado',0)
                ->pluck('eventos_registros_id')
                ->toArray();

            $actividades_montables = [];

                foreach ($usuario_actividades as $actividad) {
                    $evento = EventosRegistros::where('id', $actividad->id)
                        ->where('montable', 1)
                        ->first();

                    if ($evento) {
                        $actividades_montables[] = $evento;
                    }
                }


            dd($actividades_montables);

            foreach ($usuario_actividades as $previa_id) {
                // Obtener fechaHoraInicio y fechaHoraFinal de la actividad previa
                $previa = EventosRegistros::findOrFail($previa_id);
                dd($previa_id);
                $previa_inicio = $previa->fechaHoraInicio;
                dd($previa_inicio);
                $previa_final = $previa->fechaHoraFinal;

                // Comparar con la actividad que se quiere registrar
                if ( ($fechaHoraInicio >= $previa_inicio && $fechaHoraInicio < $previa_final) ||
                     ($fechaHoraFinal > $previa_inicio && $fechaHoraFinal <= $previa_final) ||
                     ($fechaHoraInicio <= $previa_inicio && $fechaHoraFinal > $previa_inicio) ||
                     ($fechaHoraInicio >= $previa_inicio && $fechaHoraFinal <= $previa_final) ) {
                    //return response()->json(['error' => 'La actividad choca con otra a la que ya se ha registrado'], 400);
                    return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'La actividad choca con otra a la que ya se ha registrado.');
                }
            }

        }
        /*
        //Revisa si el horario es válido
        if( !$ValidarHorarioUsuario){
            return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'El horario de la actividad que elegiste interfiere con una actividad previamente registrada.');
        }
        */
        $ValidarConteo = UsuarioConteos::where('users_id', '=', Auth::user()->id)
                                        ->where('tipos_de_registros_id', '=', $request->TipoDeActividad)->first();

        $ValidarRegistroActividadDoble = UsuarioRegistros::where('users_id', '=', Auth::user()->id)
                                                            ->where('tipos_de_registros_id', '=', $request->TipoDeActividad)
                                                            ->where('eventos_registros_id', '=', $request->Actividad)
                                                            ->where('habilitado', '=', 0)
                                                            ->first();


        if($ValidarRegistroActividadDoble){
            return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'No puedes registrarte dos veces a una actividad.');
        }

        $FechaHoraActual = NOW();
        if($ValidarActividad->fechaHoraVinculo < $FechaHoraActual){
            return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'El tiempo para registrarse en esa actividad ya expiró.');
        }

        if( $ValidarActividad->tipos_de_registros_id != $request->TipoDeActividad ){
            return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'La actividad no corresponde con la categoría de actividad.');
        }

        if($ValidarConteo){

            if( ($ValidarTipoDeActividad->maxCantidad > $ValidarConteo->Cantidad) || $ValidarTipoDeActividad->maxCantidad == -1){

                $ConteoActual = $ValidarConteo->Cantidad + 1;
                $ValidarConteo->update([
                    'Cantidad' => $ConteoActual
                ]);

                $NuevoUsuarioRegistros = UsuarioRegistros::create([
                    'users_id' => Auth::user()->id,
                    'tipos_de_registros_id' => $request->TipoDeActividad,
                    'eventos_registros_id' => $request->Actividad,
                ]);

                $ActualizarActividadVinculos = $ValidarActividad->vinculosActuales + 1;

                $ValidarActividad->update([
                    'vinculosActuales' => $ActualizarActividadVinculos,
                ]);

            }else{
                return redirect()->route('mis_actividades.nuevo')->with('mensaje', 'Ya alcanzaste el límite de registros para esa categoría de actividad.');
            }

        }else{

            $ConteoNuevo = UsuarioConteos::create([
                'users_id' => Auth::user()->id,
                'tipos_de_registros_id' => $request->TipoDeActividad,
                'Cantidad' => 1,
            ]);

            $NuevoUsuarioRegistros = UsuarioRegistros::create([
                'users_id' => Auth::user()->id,
                'tipos_de_registros_id' => $request->TipoDeActividad,
                'eventos_registros_id' => $request->Actividad,
            ]);

            $ActualizarActividadVinculos = $ValidarActividad->vinculosActuales + 1;

            $ValidarActividad->update([
                'vinculosActuales' => $ActualizarActividadVinculos,
            ]);

        }

        return redirect()->route('mis_actividades.lista')->with('mensaje', 'Registro de actividad correctamente.');

    }

    public function desactivar(int $idUsuarioRegistros){

        $ActividadValidar = UsuarioRegistros::with('EventosRegistros')->where('id', '=', $idUsuarioRegistros)->where('users_id', '=', Auth::user()->id)->first();

        if( !$ActividadValidar ){
            return redirect()->route('mis_actividades.lista')->with('mensaje', 'No existe esa actividad o no tienes permiso para realizar esa acción.');
        }

        $FechaHoraActual = NOW();

        if($ActividadValidar->EventosRegistros->fechaHoraEditar < $FechaHoraActual){
            return redirect()->route('mis_actividades.lista')->with('mensaje', 'El tiempo para desvincularse en esa actividad ya expiró.');
        }

        $ValidarConteo = UsuarioConteos::where('users_id', '=', Auth::user()->id)
                                        ->where('tipos_de_registros_id', '=', $ActividadValidar->tipos_de_registros_id)->first();

        $ConteoActual = $ValidarConteo->Cantidad - 1;

        $ValidarConteo->update([
            'Cantidad' => $ConteoActual
        ]);

        $ActualizarVinculosEventosRegistros = EventosRegistros::find($ActividadValidar->eventos_registros_id);

        $ActualizarActividadVinculos = $ActualizarVinculosEventosRegistros->vinculosActuales - 1;

        $ActualizarVinculosEventosRegistros->update([
            'vinculosActuales' => $ActualizarActividadVinculos,
        ]);

        $ActividadValidar->update([
            'habilitado' => 1,
        ]);

        return redirect()->route('mis_actividades.lista')->with('mensaje', 'Te desvinculaste de la actividad.');

    }

}