<repo_name>OSBRProj/EduLabzz1<file_sep>/app/Turma.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class Turma extends Model
{
    //Preenchiveis
    protected $fillable = [
        'id',
        'user_id',
        'titulo',
        'descricao',
        'codigo_convite',
        'postagem_aberta',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'descricao'       => '',
        'codigo_convite'  => '',
        'postagem_aberta' => 1,
    ];

    public function postagens()
    {
        return $this->hasMany('App\PostagemTurma', 'turma_id')->with('user')->orderBy('created_at', 'desc');
    }

    public function postagens_comentarios()
    {
        return $this->hasMany('App\PostagemTurma', 'turma_id')->with('user', 'comentarios')->orderBy('created_at', 'desc');
    }

    public function alunos()
    {
        return $this->hasMany('App\AlunoTurma', 'turma_id');
    }

    public function alunos_user()
    {
        return $this->hasMany('App\AlunoTurma', 'turma_id')->with('user');
    }

    public function escola()
    {
        return $this->belongsTo('App\Escola', 'escola_id')->withDefault([
            'id' => "1",
            'titulo' => "<NAME>"
        ]);
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

    public function professor()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/Entities/Habilidade/Repository.php
<?php

namespace App\Entities\Habilidade;

class Repository
{
    private $habilidade;

    public function __construct(Habilidade $habilidade)
    {
        $this->habilidade = $habilidade;
    }

    public function all()
    {
        return $this->habilidade->orderBy('id', 'DESC')->get();
    }

    public function categorias()
    {
        return $this->habilidade->all()->pluck('categoria')->unique()->toArray();
    }

    public function store($values)
    {
        return $this->habilidade->create($values);
    }

    public function update($id, $values)
    {
        return $this->habilidade->find($id)->update($values);
    }

    public function delete($id)
    {
        return $this->habilidade->find($id)->delete();
    }

}
<file_sep>/app/Http/Controllers/Audio/Api/AudioApiController.php
<?php

namespace App\Http\Controllers\Audio\Api;

use App\Entities\Audio\Audio;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class AudioApiController extends Controller
{
    public function listar($filter = null)
    {
        try {
            if ($filter !== null) {
                return response()->json(Audio::where('categoria_id', $filter)->orderBy('id', 'DESC')->get());
            }
            return response()->json(Audio::orderBy('id', 'DESC')->get());
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao listar.", "message:" => $exception->getMessage()]);
        }
    }




    public function show($idAudio)
    {
        try {
            $audio = Audio::find($idAudio);
            if (!$audio) {
                return response()->json(['error' => 'Nenhum áudio foi encontrado']);
            }
            return response()->json($audio);
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao encontrar", "message:" => $exception->getMessage()]);
        }
    }

}
<file_sep>/README.md
## <NAME>

# Iniciando

Após o git clone do projeto:

```bash
$ cd crud_api
$ docker-compose up -d -- build
```
Acompanhar a instalação e atualização das dependências do composer através do comando:

```bash
$ docker-compose logs -f app
```

Após a instalação das dependências, é possível acessar o projeto em `localhost`# edulabzz
<file_sep>/app/Http/Middleware/ApiAuthenticate.php
<?php

namespace App\Http\Middleware;
use Illuminate\Support\Facades\Auth;

use Closure;

class ApiAuthenticate
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next)
    {

        if( Auth::check() == false )
        {
            return response()->json([ "error" => "Não autenticado", "auth" => false ]);
        }


        return $next($request);
    }
}
<file_sep>/app/AlunoTurma.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class AlunoTurma extends Model
{
    protected $table = 'aluno_turma';

    //Preenchiveis
    protected $fillable = [
        'turma_id',
        'user_id',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [

    ];

    public function turma_professor()
    {
        return $this->belongsTo('App\Turma', 'turma_id')->with('professor');
    }
    
    public function gamificacao()
    {
        return $this->hasMany('App\Entities\GamificacaoUsuario\GamificacaoUsuario', 'user_id');
    }

    public function turma()
    {
        return $this->belongsTo('App\Turma', 'turma_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/database/migrations/2019_08_08_111945_create_progresso_conteudo_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateProgressoConteudoTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('progresso_conteudo', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('conteudo_id');
			$table->integer('user_id');
			$table->integer('tipo');
			$table->float('progresso', 10, 0);
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('progresso_conteudo');
	}

}
<file_sep>/app/Entities/Anotacao/Anotacao.php
<?php

namespace App\Entities\Anotacao;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class Anotacao extends Model
{
    protected $table = 'anotacoes';

    //Preenchiveis
    protected $fillable = [
        'id',
        'user_id',
        'conteudo_id',
        'pagina',
        'trecho',
        'anotacao',
        'pos_y',
        'pos_x',
        'start',
        'end',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'anotacao' => '',
        'pos_y' => 0,
        'pos_x' => 0,
        'start' => 0,
        'end' => 0,
    ];

    public function conteudo()
    {
        return $this->belongsTo('App\Conteudo', 'conteudo_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/Entities/Favorito/Favorito.php
<?php

namespace App\Entities\Favorito;

use App\Conteudo;
use App\Entities\Album\Album;
use Illuminate\Database\Eloquent\Model;
use Laracasts\Presenter\PresentableTrait;

class Favorito extends Model
{

    protected $table = "favoritos";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'referencia_id',
        'tipo',
        'conteudo_id',
        'album_id',
        'audio_id',
    ];




    public function conteudo()
    {
        return $this->belongsTo(Conteudo::class, 'referencia_id');
    }




    public function albums()
    {
        return $this->belongsTo(Album::class, 'album_id');
    }




    public function audios()
    {
        return $this->belongsTo(Album::class, 'audio_id');
    }


}
<file_sep>/app/User.php
<?php

namespace App;

use App\Entities\Album\Album;
use Illuminate\Notifications\Notifiable;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Support\Carbon;

class User extends Authenticatable
{
    use Notifiable;

    protected $fillable = [
        'name',
        'email',
        'password',
        'ra',
        'img_perfil',
        'nome_completo',
        'data_nascimento',
        'genero',
        'descricao',
        'escola_id',
        'permissao',
        'ultima_atividade',
    ];

    protected $hidden = [
        'password',
        'remember_token',
    ];

    protected $attributes = [
        'ra'               => null,
        'img_perfil'       => '',
        'nome_completo'    => '',
        'data_nascimento'  => '',
        'genero'           => '',
        'descricao'        => '',
        'escola_id'        => 1,
        'permissao'        => 'A',
        'ultima_atividade' => '0000-00-00 00:00:00',
    ];

    protected static $permissoes = [
        'Aluno',
        'Professor',
        'Gestor',
        'Administrador',
        'Sem acesso à plataforma',
    ];




    public function albuns()
    {
        return $this->hasMany(Album::class, 'user_id')->orderBy('id', 'DESC');
    }




    // Mutators
    public function getNameAttribute($value)
    {
        return ucwords($value);
    }


    public function getBornDateAttribute($value)
    {
        return date('d/m/Y', strtotime($this->attributes['born_date']));
    }



    public function getAvatarAttribute()
    {
        $path = route('usuario.perfil.image', [ $this->id ]);

        return $path;

        // $path = env("APP_URL") . '/uploads/usuarios/perfil/' . $this->attributes['avatar'];

        // if($this->attributes['avatar'] == ''){
        //     return null;
        // }

        // return $path;
    }




    public function getPermissaoNameAttribute()
    {
        return $this->PermissaoName($this->permissao);
    }




    public function turmas_aluno()
    {
        return $this->hasMany('App\AlunoTurma', 'user_id')->with('turma_professor');
    }




    public function turmas_instrutor()
    {
        return $this->hasMany('App\Turma', 'user_id');
    }




    public function escola()
    {
        return $this->belongsTo('App\Escola', 'escola_id');
    }




    public function badges_user()
    {
        return $this->hasMany('App\BadgeUsuario', 'user_id')->with('Badge');
    }




    public function progressos()
    {
        return $this->hasMany('App\ProgressoConteudo', 'user_id');
    }




    public function endereco()
    {
        return $this->hasOne('App\EnderecoUser', 'user_id')
            ->withDefault([
                'user_id'     => null,
                'cep'         => null,
                'uf'          => null,
                'cidade'      => null,
                'bairro'      => null,
                'logradouro'  => null,
                'numero'      => null,
                'complemento' => null,
            ]);
    }



    public function notificacoes()
    {
        return $this->hasOne('App\ConfiguracoesNotificacoesUser', 'user_id')
            ->withDefault([
                'user_id'     => 1,
                'rcb_notif_resp_professor'  => 1,
                'rcb_notif_resp_aluno'      => 1,
                'rcb_notif'                 => 1,
            ]);
    }



    public function gamificacao()
    {
        return $this->hasOne('App\Entities\GamificacaoUsuario\GamificacaoUsuario', 'user_id')
            ->withDefault([
                'xp' => 0
            ]);
    }




    public static function PermissaoNamed($usuarios)
    {
        foreach ($usuarios as $usuario) {
            if (strrpos(mb_strtoupper($usuario->permissao, 'UTF-8'), "Z") !== false) {
                $usuario->permissao_name = self::$permissoes[3];
            } elseif (strrpos(mb_strtoupper($usuario->permissao, 'UTF-8'), "G") !== false) {
                $usuario->permissao_name = self::$permissoes[2];
            } elseif (strrpos(mb_strtoupper($usuario->permissao, 'UTF-8'), "P") !== false) {
                $usuario->permissao_name = self::$permissoes[1];
            } elseif (strrpos(mb_strtoupper($usuario->permissao, 'UTF-8'), "") !== false) {
                $usuario->permissao_name = self::$permissoes[4];
            } else {
                $usuario->permissao_name = self::$permissoes[0];
            }
        }

        return $usuarios;
    }




    public static function PermissaoName($permissao)
    {
        if (strtoupper($permissao) == "Z") {
            return self::$permissoes[3];
        }
        if (strtoupper($permissao) == "G") {
            return self::$permissoes[2];
        }
        if (strtoupper($permissao) == "P") {
            return self::$permissoes[1];
        } else {
            return self::$permissoes[0];
        }

    }
}
<file_sep>/app/Http/Controllers/Trilhas/Admin/TrilhasController.php
<?php

namespace App\Http\Controllers\Trilhas\Admin;

use Illuminate\Support\Facades\Input;

use App\Curso;
use App\Entities\Trilhas\Trilhas;
use App\Entities\Trilhas\TrilhasCurso;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;

class TrilhasController extends Controller
{
    public function index()
    {
        $trilhas = Trilhas::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $trilhas->when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $is_admin = strtoupper(Auth::user()->permissao) == "Z";

        $trilhas->when($is_admin == false, function ($query) {
            return $query->where('user_id', '=', Auth::user()->id);
        });

        $trilhas = $trilhas
        // ->where('user_id', Auth::user()->id)
        ->orderBy('id', 'DESC')
        ->get();

        return view('pages.trilhas.admin.index', compact('trilhas'));
    }

    public function create()
    {

        (Auth::user()->permissao == 'Z' ? $cursos = Curso::orderBy('id', 'DESC')->get() : $cursos = Curso::where('user_id', Auth::user()->id)->orderBy('id', 'DESC')->get());
        return view('pages.trilhas.admin.create', compact('cursos'));
    }




    public function store(Request $request)
    {
        if (!$request->get('curso_id')) {
            return redirect()->back()->withErrors(['Selecione pelo menos um curso para sua trilha!'])->withInput();
        }
        $this->validate($request, [
            'titulo' => 'required',
            'capa'   => 'required'
        ]);

        $trilha = Trilhas::create([
            'user_id'   => Auth::user()->id,
            'titulo'    => $request->get('titulo'),
            'descricao' => $request->get('descricao'),
        ]);

        $trilha->cursos()->attach($request->get('curso_id'));

       /* foreach ($request->get('curso_id') as $cursoId) {
            TrilhasCurso::create([
                'trilha_id' => $trilha->id,
                'curso_id'  => $cursoId
            ]);
        }*/

        if ($request->capa != null) {
            $fileExtension = \File::extension($request->capa->getClientOriginalName());
            $newFileNameCapa = md5($request->capa->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

            $pathCapa = $request->capa->storeAs('trilhas/capas', $newFileNameCapa, 'public_uploads');

            if (!Storage::disk('public_uploads')->put($pathCapa, file_get_contents($request->capa))) {
                \Session::flash('middle_popup', 'Ops! Não foi possivel enviar a capa.');
                \Session::flash('popup_style', 'danger');
            } else {
                $trilha->capa = $newFileNameCapa;
                $trilha->save();
            }
        }
        return redirect()->back()->with('message', 'Trilha cadastrada com sucesso!');
        // return redirect()->route('trilhas.index')->with('message', 'Trilha cadastrada com sucesso!');
    }




    public function edit($idTrilha)
    {
        (Auth::user()->permissao == 'Z' ? $cursos = Curso::orderBy('id', 'DESC')->get() : $cursos = Curso::where('user_id', Auth::user()->id)->orderBy('id', 'DESC')->get());
        $trilha = Trilhas::find($idTrilha);

        return view('pages.trilhas.admin.edit', compact('trilha', 'cursos'));
    }




    public function update(Request $request, $idTrilha)
    {
        if (!$request->get('curso_id')) {
            return redirect()->back()->withErrors(['Selecione pelo menos um curso para sua trilha!'])->withInput();
        }
        $this->validate($request, ['titulo' => 'required']);

        $capa = $request->get('capa_atual');
        if ($request->file('capa')) {
            $fileExtension = \File::extension($request->capa->getClientOriginalName());
            $newFileNameCapa = md5($request->capa->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

            $pathCapa = $request->capa->storeAs('trilhas/capas', $newFileNameCapa, 'public_uploads');

            if (!Storage::disk('public_uploads')->put($pathCapa, file_get_contents($request->capa))) {
                \Session::flash('middle_popup', 'Ops! Não foi possivel enviar a capa.');
                \Session::flash('popup_style', 'danger');
            } else {
                $capa = $newFileNameCapa;
                Storage::disk('public_uploads')->delete('trilhas/capas/' . $request->get('capa_atual'));
            }
        }


        $trilha = Trilhas::find($idTrilha);
        $trilha->update([
            'titulo'    => $request->get('titulo'),
            'capa'      => $capa,
            'descricao' => $request->get('descricao')
        ]);


        $trilha->cursos()->sync($request->get('curso_id'));


        return redirect()->route('gestao.trilhas.listar')->with('message', 'Trilha atualizada com sucesso!');


    }




    public function destroy($idTrilha)
    {
        $trilha = Trilhas::find($idTrilha);
        if (!$trilha) {
            return redirect()->back()->withErrors(['Trilha não encontrada!']);
        }

        if (Storage::disk('public_uploads')->has('trilhas/capas/' . $trilha->capa)) {
            Storage::disk('public_uploads')->delete('trilhas/capas/' . $trilha->capa);
        }


        TrilhasCurso::where('trilha_id', $idTrilha)->delete();
        $trilha->delete();

        return redirect()->back()->with('message', 'Trilha excluida com sucesso!');

    }


}
<file_sep>/app/Entities/Agenda/Repository.php
<?php

namespace App\Entities\Agenda;


class Repository
{
    
    private $agenda;
    
    public function __construct(Agenda $agenda)
    {
        $this->agenda = $agenda;
    }
    
    public function all($idUser)
    {
        return $this->agenda->where('user_id', $idUser)->get();
    }
    
    public function find($id)
    {
        return $this->agenda->find($id);
    }
    
    public function store($values)
    {
        return $this->agenda->create($values);
    }
    
    
    public function update($id, $values)
    {
        return $this->agenda->find($id)->update($values);
    }
    
    
    public function delete($id)
    {
        return $this->agenda->find($id)->delete();
    }
    
}
<file_sep>/app/HelperClass.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

use Illuminate\Pagination\Paginator;
use Illuminate\Support\Collection;
use Illuminate\Pagination\LengthAwarePaginator;

use Request;

class HelperClass extends Model
{
    public static function AppendToUrl($newQueries)
    {
        //Retrieve current query strings:
        $currentQueries = Request::query();

        //Merge together current and new query strings:
        $allQueries = array_merge($currentQueries, $newQueries);

        //Generate the URL with all the queries:
        return Request::fullUrlWithQuery($allQueries);
    }

    /**
     * Gera a paginação dos itens de um array ou collection.
     *
     * @param array|Collection $items
     * @param int $perPage
     * @param int $page
     * @param array $options
     *
     * @return LengthAwarePaginator
     */
    public static function paginate($items, $perPage = 15, $page = null, $options = [])
    {
        $page = $page ?: (Paginator::resolveCurrentPage() ?: 1);
        $items = $items instanceof Collection ? $items : Collection::make($items);

        $pagination = new LengthAwarePaginator($items->forPage($page, $perPage), $items->count(), $perPage, $page, $options);

        return $pagination;
    }

    public static function RandomString($length)
    {
        $char = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        $char = str_shuffle($char);
        for ($i = 0, $rand = '', $l = strlen($char) - 1; $i < $length; $i++) {
            $rand .= $char{mt_rand(0, $l)};
        }

        return $rand;
    }

    public static function needSideBar()
    {
        if (Request::is('home') || \Request::is('playlists') || \Request::is('plano-de-estudos') || \Request::is('canal-do-professor/*/*') || Request::is('grade-de-aula/data/*') || Request::is('catalogo') || Request::is('historico') || Request::is('historico/*') || Request::is('favoritos') || Request::is('favoritos/*') || Request::is('ranking') || Request::is('plano-de-aulas/*') || Request::is('estatisticas') || Request::is('catalogo') || Request::is('catalogo/*') || Request::is('biblioteca') || Request::is('play/*') ||
            Request::is('aplicacao/*') || Request::is('glossario') || Request::is('glossario/*') || Request::is('perfil/*') ||
            Request::is('turmas') || Request::is('turma/*') || Request::is('habilidades') || Request::is('habilidades/*') || Request::is('agenda') || Request::is('agenda/*') || Request::is('teste-nivelamento') || Request::is('teste-nivelamento/*') ||
            Request::is('professor/*') ||
            Request::is('artigos') ||            Request::is('artigos/*') ||
            Request::is('escola/*/mural') ) {
            return true;
        } else {
            return false;
        }
    }

    public static function needGestaoSideBar()
    {
        if (Request::is('gestao/*') || Request::is('dashboard/*')) {
            return true;
        } else {
            return false;
        }
    }

    public static function getAplicacaoAtual()
    {
        if(Request::is('dashboard/*') || Request::is('gestao/escolas') || Request::is('gestao/usuarios'))
        {
            return "manager";
        }
        else if(Request::is('gestao/escola/*'))
        {
            return "school";
        }
        else if (Request::is('gestao/*'))
        {
            return "master";
        }
        else if (Request::is('home') || \Request::is('playlists') || \Request::is('plano-de-estudos') || \Request::is('canal-do-professor/*/*') || Request::is('grade-de-aula/data/*') || Request::is('catalogo') || Request::is('historico') || Request::is('historico/*') || Request::is('favoritos') || Request::is('favoritos/*') || Request::is('ranking') || Request::is('plano-de-aulas/*') || Request::is('estatisticas') || Request::is('catalogo') || Request::is('catalogo/*') || Request::is('biblioteca') || Request::is('play/*') ||
            Request::is('aplicacao/*') || Request::is('glossario') || Request::is('glossario/*') || Request::is('perfil/*') ||
            Request::is('turmas') || Request::is('turma/*') || Request::is('habilidades') || Request::is('habilidades/*') || Request::is('agenda') || Request::is('agenda/*') || Request::is('teste-nivelamento') || Request::is('teste-nivelamento/*') ||
            Request::is('professor/*') ||
            Request::is('artigos') ||            Request::is('artigos/*') ||
            Request::is('escola/*/mural') ) {
            return "play";
        }
        else
        {
            return false;
        }
    }

    public static function needDocSideBar()
    {
        if (Request::is('dashboard/documentacao/*')) {
            return true;
        }
        return false;
    }

    public static function needSideBarButton()
    {
        if (Request::is('home') || \Request::is('plano-de-estudos') || \Request::is('canal-do-professor/*/*') || Request::is('grade-de-aula/data/*') || Request::is('teste-nivelamento') || Request::is('playlists') || Request::is('catalogo') || Request::is('historico') || Request::is('historico/*') || Request::is('favoritos') || Request::is('favoritos/*') || Request::is('ranking') || Request::is('plano-de-aulas/*') || Request::is('estatisticas') || Request::is('catalogo') || Request::is('catalogo/*') || Request::is('biblioteca') || Request::is('play/*') ||
            Request::is('aplicacao/*') || Request::is('glossario') || Request::is('glossario/*') || Request::is('perfil/*') ||
            Request::is('turmas') || Request::is('turma/*') || Request::is('habilidades') || Request::is('habilidades/*') || Request::is('agenda') ||
            Request::is('professor/*') || Request::is('gestao/*') || Request::is('dashboard/*') ||
            Request::is('artigos') || Request::is('artigos/*') ||
            Request::is('escola/*/mural') ) {
            return true;
        } else {
            return false;
        }
    }

    public static function previousRoute()
    {
        try
        {
            if(\URL::previous())
            {
                return app('router')->getRoutes()->match(app('request')->create( str_replace(env('APP_URL'), "", \URL::previous())  ))->getName();
            }
            else
            {
                return null;
            }
        }
        catch (\Throwable $th)
        {
            return null;
        }
    }

    public static function comparePreviousRoute($routeName)
    {
        if(\URL::previous())
        {
            if($routeName == self::previousRoute())
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return null;
        }
    }

    public static function drawCarrinho()
    {
        $html = "";

        if(\Session::has('carrinho') ? count(\Session::get('carrinho')) > 0 : false)
        {
            $total = 0;

            foreach(\Session::get('carrinho') as $produto)
            {
                $total += $produto->preco;

                $html = $html . '<div class="dropdown-item px-3 py-1 mb-1" style="border-bottom:  1px solid #f8f8f8;width: auto;clear: both;font-weight: 400;color: #212529;text-align: inherit;white-space: nowrap;background-color: transparent;border: 0;flex-direction: row;display: flex; max-height: 90px; align-items: center;">';

                if($produto->tipo == 2 && $produto->curso != null)
                {
                    $html = $html . '<div class="" style="background-image: url(' . env('APP_LOCAL') . '/uploads/cursos/capas/' .  $produto->curso->capa . ');background-size: cover; background-position: 50% 50%; background-repeat: no-repeat; width: 60px; height: 60px; margin-right: 10px; display: inline-block; vertical-align: middle;">
                    </div>';
                }

                $html = $html . '
                        <div>
                            <b style="max-width: 200px;white-space: normal; overflow: hidden;" class="pl-2 mb-0">
                                ' . ucfirst($produto->titulo) . '
                            </b>

                            <p class="small pl-2 mb-0">' . ucfirst($produto->descricao) . '</p>

                            <p style="" class="pl-2 mb-0">
                                R$ ' . number_format($produto->preco, 2, ',', '.') . ($produto->quantidade >= 2 ? ' (' . $produto->quantidade . 'x)' : '')  . '
                            </p>
                        </div>
                        <a class="text-primary ml-auto" href="' . route('carrinho.remover', ['idProduto' => $produto->id, 'return' => Request::url()]) .'" style="align-self: flex-start; justify-self: flex-end;"><i class="fa fa-times fa-fw fa-sm" aria-hidden="true"></i></a>
                    ';

                $html = $html . '</div>';
            }

            $html = $html . '<div class="dropdown-item px-3 py-3" style="color: #60748A;min-width:  340px;border-bottom:  2px solid #E3E5F0;">
                <h5>
                    <span class="text-lightgray">Total: </span>
                    R$ ' . number_format($total, 2, ',', '.') . '
                </h5>
                ' . (Request::is('carrinho') == false ? '<a href="' . route('carrinho.index') . '" class="btn btn-primary btn-block text-center">Ir para o carrinho</a>' : '') . '
            </div>';
        }
        else
        {
            $html = '
                <div class="dropdown-item px-4 py-3" style="color: #60748A;min-width:  340px;border-bottom:  2px solid #E3E5F0;">
                    Seu carrinho está vazio.
                </div>
            ';
        }

        return $html;
    }

    public static function linkfy($text)
    {
        $url = '~(?:(https?)://([^\s<]+)|(www\.[^\s<]+?\.[^\s<]+))(?<![\.,:])~i';

        $string = preg_replace($url, '<a href="$0" target="_blank" title="$0">$0</a>', $text);

        return  $string;
    }
}
<file_sep>/app/Entities/HabilidadeUsuario/Api/Repository.php
<?php

namespace App\Entities\HabilidadeUsuario\Api;

use App\Entities\HabilidadeUsuario\HabilidadeUsuario;

class Repository
{
  private $habilidadeUsuario;
  
  public function __construct(HabilidadeUsuario $habilidadeUsuario)
  {
    $this->habilidadeUsuario = $habilidadeUsuario;
  }
  
  public function store($values)
  {
    return $this->habilidadeUsuario->create($values);
  }
  
}<file_sep>/app/Http/Controllers/ConteudoController.php
<?php

namespace App\Http\Controllers;

use App\Entities\Historico\Historico;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Illuminate\Support\Facades\Storage;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Escola;
use App\Categoria;
use App\Conteudo;
use App\ConteudoAula;
use App\ProgressoConteudo;
use App\InteracaoConteudo;
use App\AvaliacaoConteudo;
use App\AvaliacaoInstrutor;
use App\Metrica;

class ConteudoController extends Controller
{
    function playConteudo($idConteudo, Request $request)
    {
        if (Conteudo::find($idConteudo))
        {
            $conteudo = Conteudo::find($idConteudo);
        }
        else
        {
            return Redirect::back()->withErrors(['Conteúdo não encontrado!']);
        }


        // Histórico
        if (Historico::where([
                ['user_id', Auth::user()->id],
                ['referencia_id', $idConteudo],
                ['tipo', 2],
                ['created_at', '>', (Carbon::now()->subMinutes(15))]])
                ->exists() == false)
                {
            Historico::create([
                'user_id'       => Auth::user()->id,
                'referencia_id' => $idConteudo,
                'tipo'          => 2
            ]);
        }

        if ($conteudo->status != 1)
        {
            if (Auth::check() ? (strtolower(Auth::user()->permissao) != "z" && $conteudo->user_id != Auth::user()->id) : true)
            {
                return Redirect::back()->withErrors(['Conteúdo não encontrado!']);
            }
            else
            {
                Session::flash('previewMode', true);
            }
        }

        if ($conteudo->tipo == 2) {
            if (strpos($conteudo->conteudo, "soundcloud.com") !== false) {
                $conteudo->conteudo = '<iframe width="100%" height="166" scrolling="no" frameborder="no" allow="autoplay" src="https://w.soundcloud.com/player/?url=' . $conteudo->conteudo . '&color=%236766a6&auto_play=false&hide_related=false&show_comments=true&show_user=true&show_reposts=false&show_teaser=true"></iframe>';
            } elseif (strpos($conteudo->conteudo, "http") !== false || strpos($conteudo->conteudo, "www") !== false) {
                $conteudo->conteudo = '<audio controls style="width: 100%;">
                    <source src="' . $conteudo->conteudo . '" type="audio/mp3">
                    Your browser does not support the audio element.
                </audio>';
            } else {
                $conteudo->conteudo = '<audio controls style="width: 100%;">
                    <source src="' . route('conteudo.play.get-arquivo', ['idConteudo' => $idConteudo]) . '" type="audio/mp3">
                    Your browser does not support the audio element.
                </audio>';
            }
        } else if ($conteudo->tipo == 3) {
            if (strpos($conteudo->conteudo, "youtube") !== false || strpos($conteudo->conteudo, "youtu.be") !== false) {
                if (strpos($conteudo->conteudo, "youtu.be") !== false) {
                    $conteudo->conteudo = str_replace("youtu.be", "youtube.com", $conteudo->conteudo);
                }

                $conteudo->conteudo = str_replace("/watch?v=", "/embed/", $conteudo->conteudo);

                if (strpos($conteudo->conteudo, "&") !== false) {
                    $conteudo->conteudo = substr($conteudo->conteudo, 0, strpos($conteudo->conteudo, "&"));
                }

                $conteudo->conteudo = '<iframe src="' . $conteudo->conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                </iframe>';

            } elseif (strpos($conteudo->conteudo, "vimeo") !== false) {
                if (strpos($conteudo->conteudo, "player.vimeo.com") === false)
                    $conteudo->conteudo = str_replace("vimeo.com/", "player.vimeo.com/video/", $conteudo->conteudo);

                $conteudo->conteudo = '<iframe src="' . $conteudo->conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen>
                </iframe>';
            } else {
                $conteudo->conteudo = '<video controls style="width: 100%; height: 41vw;">
                    <source src="' . route('conteudo.play.get-arquivo', ['idConteudo' => $idConteudo]) . '" type="video/mp4">
                    Your browser does not support the audio element.
                </video>';
            }
        }
        else if ($conteudo->tipo == 4)
        {

            if(strpos($conteudo->conteudo, "http") === false && strpos($conteudo->conteudo, "www") === false)
            {
                $url_conteudo = route('conteudo.play.get-arquivo', ['idConteudo' => $idConteudo]);
            }
            else
            {
                $url_conteudo = $conteudo->conteudo;
            }

            if (strpos($conteudo->conteudo, ".ppt") !== false || strpos($conteudo->conteudo, ".pptx") !== false)
            {
                $conteudo->conteudo = '<iframe src="https://view.officeapps.live.com/op/view.aspx?src=' . $url_conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                </iframe>';
            }
            elseif (strpos($conteudo->conteudo, ".html") !== false)
            {
                $conteudo->conteudo = '<iframe src="' . $url_conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                </iframe>';
            }
            elseif (strpos($conteudo->conteudo, "drive.google.com/file") !== false)
            {
                if (strpos($conteudo->conteudo, "/view") !== false)
                {
                    $url_conteudo = str_replace("/view", "/preview", $url_conteudo);
                }

                $conteudo->conteudo = '<iframe src="' . $url_conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                </iframe>';
            }
            else
            {
                $conteudo->conteudo = '<object data="' . $url_conteudo . '" type="application/pdf" style="width: 100%; height: 41vw;">
                </object>';
            }

        }
        else if ($conteudo->tipo == 11)
        {
            $url_apostila = env("APP_LOCAL") . '/uploads/apostilas/' . $conteudo->id;

            $conteudo->conteudo = '<iframe src="' . env("APP_LOCAL") . '/leitor_apostila/' . $conteudo->id . '?conteudo_id=' . $conteudo->id . '&url=' . $url_apostila . '" style="width: 100%; height: 115vh;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                </iframe>';
        }

        $conteudo->qtAvaliacoesPositivas = AvaliacaoConteudo::where([['avaliacao', '=', '1'], ['conteudo_id', '=', $idConteudo]])->count();

        $conteudo->qtAvaliacoesNegativas = AvaliacaoConteudo::where([['avaliacao', '=', '0'], ['conteudo_id', '=', $idConteudo]])->count();

        $conteudo->minhaAvaliacao = AvaliacaoConteudo::where([['user_id', '=', Auth::user()->id], ['conteudo_id', '=', $idConteudo]])->first();

        if (!ProgressoConteudo::where([['conteudo_id', '=', $idConteudo], ['tipo', '=', 2], ['user_id', '=', Auth::user()->id]])->exists()) {
            ProgressoConteudo::create([
                'conteudo_id' => $idConteudo,
                'tipo'        => 2,
                'user_id'     => Auth::user()->id
            ]);
        }

        return view('play.conteudo')->with(compact('conteudo'));
    }

    function playGetArquivo($idConteudo)
    {
        if (Conteudo::where([['id', '=', $idConteudo]])->first() != null)
        {
            $conteudo = Conteudo::where([['id', '=', $idConteudo]])->first();

            if (strpos($conteudo->conteudo, ".ppt") === false && strpos($conteudo->conteudo, ".html") === false)
            {
                if (!Auth::check())
                {
                    return response()->json(['error' => 'Usuário não autenticado!']);
                }
            }

            $idCurso = ConteudoAula::where([['conteudo_id', '=', $idConteudo]])->first() != null ? ConteudoAula::where([['conteudo_id', '=', $idConteudo]])->first()->curso_id : null;

            // dd($idCurso);

            if (\Storage::disk('local')->has('uploads/conteudos/' . $conteudo->conteudo))
            {
                return \Storage::disk('local')->response('uploads/conteudos/' . $conteudo->conteudo);
            }
            else if(\Storage::disk('local')->has('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo) && $idCurso != null)
            {
                $filePath = 'uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo;

                return \Storage::disk('local')->response($filePath);
            }
            else
            {
                return $conteudo->conteudo;
            }



        }
        else
        {
            return response()->view('errors.404');
        }
    }

    public function postEnviarAvaliacaoConteudo($idConteudo, Request $request)
    {
        if (Conteudo::where([['id', '=', $idConteudo]])->first() != null) {
            AvaliacaoConteudo::updateOrCreate(
                [
                    'user_id'     => Auth::user()->id,
                    'conteudo_id' => $idConteudo,
                ],
                ['avaliacao' => $request->avaliacao]
            );

            return response()->json(['success' => 'Avaliação enviada com sucesso!']);
        } else {
            return response()->json(['error' => 'Conteúdo não encontrado!']);
        }
    }

    public function postEnviarInteracaoConteudo($idConteudo, Request $request)
    {
        if (Conteudo::where([['id', '=', $idConteudo]])->first() != null) {
            InteracaoConteudo::create([
                'conteudo_id' => $idConteudo,
                'user_id'     => Auth::user()->id,
                'tipo'        => $request->tipo,
                'inicio'      => $request->inicio
            ]);

            return response()->json(['success' => 'Interação enviada com sucesso!']);
        } else {
            return response()->json(['error' => 'Conteúdo não encontrado!']);
        }
    }

    public function postEnviarAvaliacaoProfessor($idInstrutor, Request $request)
    {
        if ($request->comentario == null) {
            $request->comentario = '';
        }

        AvaliacaoInstrutor::updateOrCreate(
            [
                'user_id'      => Auth::user()->id,
                'instrutor_id' => $idInstrutor
            ],
            ['avaliacao' => $request->avaliacao, 'descricao' => $request->comentario]
        );

        return response()->json(['success' => 'Avaliação enviada com sucesso!']);
    }

}
<file_sep>/app/Http/Controllers/EscolaController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;
use Redirect;
use Session;

use App\User;
use App\Escola;
use App\Turma;
use App\AlunoTurma;
use App\Aplicacao;
use App\Conteudo;
use App\Metrica;
use App\AvaliacaoConteudo;
use App\AvaliacaoInstrutor;
use App\InteracaoConteudo;
use App\ProgressoConteudo;

use App\LiberacaoAplicacaoEscola;
use App\CodigoAcessoEscola;

use App\PostagemEscola;
use App\ComentarioPostagemEscola;

use App\PostagemGestaoEscola;
use App\ComentarioPostagemGestaoEscola;


use App\CodigoTransmissao;


class EscolaController extends Controller
{

    //
    // Mural de gestao da escola
    //

    public function muralGestaoEscola($escola_id)
    {
        if (Input::get('qt') == null)
        {
            $amount = 10;
        }
        else
        {
            $amount = Input::get('qt');
        }

        if (Escola::find($escola_id) == null)
        {
            return Redirect::back()->withErrors(['Escola não encontrada!']);
        }
        else
        {
            $escola = Escola::with('postagens_gestao', 'postagens_gestao_comentarios')->find($escola_id);

            if (strpos(Auth::user()->permissao, "G") === false && strpos(Auth::user()->permissao, "Z") === false && $escola->user_id != Auth::user()->id && Auth::user()->escola_id != $escola_id)
            {
                Session::flash('error', 'Você não faz parte desta escola!');

                return redirect()->route('catalogo');
            }

            $usuarios = User::where([['escola_id', '=', $escola_id], ['permissao', '!=', 'A']])->paginate($amount);

            // dd($escola);

            return view('gestao.gestao-escola-mural')->with(compact('escola', 'usuarios', 'amount'));
        }

    }

    public function postarMuralGestaoEscola($escola_id, Request $request)
    {
        if (Escola::find($escola_id) == null) {
            Redirect::back()->withErrors(['Escola não encontrada!']);
        } else {
            $postagem = PostagemGestaoEscola::create([
                'escola_id' => $escola_id,
                'user_id'  => Auth::user()->id,
                'conteudo' => $request->conteudo
            ]);

            if ($request->arquivo != null) {
                $originalName = mb_strtolower($request->arquivo->getClientOriginalName(), 'utf-8');

                $fileExtension = \File::extension($request->arquivo->getClientOriginalName());
                $newFileNameArquivo = md5($request->arquivo->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

                $pathArquivo = $request->arquivo->storeAs('uploads/escolas/' . $escola_id . '/arquivos', $newFileNameArquivo, 'local');

                if (!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo))) {
                    \Session::flash('error', 'Não foi possível fazer upload de seu anexo!');
                } else {
                    $postagem->update([
                        'arquivo' => $newFileNameArquivo
                    ]);
                }
            }

            return Redirect::back()->with('message', 'Postagem enviada com sucesso!');
        }
    }

    public function postExcluirPostagemGestao($escola_id, $idPostagem)
    {
        if (PostagemGestaoEscola::find($idPostagem) != null) {
            if (\Storage::disk('local')->has('uploads/escolas/' . $escola_id . '/arquivos/' . PostagemGestaoEscola::find($idPostagem)->arquivo)) {
                \Storage::disk('local')->delete('uploads/escolas/' . $escola_id . '/arquivos/' . PostagemGestaoEscola::find($idPostagem)->arquivo);
            }

            PostagemGestaoEscola::find($idPostagem)->delete();

            return Redirect::back()->with('message', 'Postagem excluída com sucesso!');
        } else {
            return Redirect::back()->withErrors(['Postagem não encontrada!']);
        }
    }

    public function postEnviarComentarioPostagemGestao($escola_id, $idPostagem, Request $request)
    {
        if (Escola::find($escola_id) == null) {
            Redirect::back()->withErrors(['Escola não encontrada!']);
        } else if (PostagemGestaoEscola::find($idPostagem) == null) {
            Redirect::back()->withErrors(['Postagem não encontrada!']);
        } else {
            $comentario = ComentarioPostagemGestaoEscola::create([
                'postagem_id' => $idPostagem,
                'user_id'     => Auth::user()->id,
                'conteudo'    => $request->conteudo
            ]);

            return Redirect::back()->with('message', 'Comentário enviado com sucesso!');
        }
    }

    public function postExcluirComentarioPostagemGestao($escola_id, $idPostagem, $idComentario)
    {
        if (ComentarioPostagemGestaoEscola::find($idPostagem) == null) {
            return Redirect::back()->withErrors(['Comentário não encontrado!']);
        } else {
            ComentarioPostagemGestaoEscola::find($idPostagem)->delete();

            return Redirect::back()->with('message', 'Comentário excluído com sucesso!');
        }
    }

    public function getArquivoGestao($escola_id, $postagem_id)
    {
        if (Escola::find($escola_id) == null) {
            Session::flash('error', 'Escola não encontrada!');

            return redirect()->route('catalogo');
        } else {
            if (PostagemGestaoEscola::find($postagem_id) == null) {
                Session::flash('error', 'Postagem não encontrada!');

                return redirect()->route('catalogo');
            } else {
                $postagem = PostagemGestaoEscola::find($postagem_id);

                if (\Storage::disk('local')->has('uploads/escolas/' . $escola_id . '/arquivos/' . $postagem->arquivo)) {
                    return \Storage::disk('local')->download('uploads/escolas/' . $escola_id . '/arquivos/' . $postagem->arquivo);
                } else {
                    Session::flash('error', 'Arquivo não encontrado!');

                    return redirect()->route('catalogo');
                }
            }
        }
    }

    //
    // Mural da escola para alunos
    //

    public function muralEscola($escola_id)
    {
        if (Input::get('qt') == null)
        {
            $amount = 10;
        }
        else
        {
            $amount = Input::get('qt');
        }

        if (Escola::find($escola_id) == null)
        {
            return Redirect::back()->withErrors(['Escola não encontrada!']);
        }
        else
        {
            $escola = Escola::with('postagens_comentarios')->find($escola_id);

            if (strpos(Auth::user()->permissao, "G") === false && strpos(Auth::user()->permissao, "Z") === false && $escola->user_id != Auth::user()->id && Auth::user()->escola_id != $escola_id)
            {
                Session::flash('error', 'Você não faz parte desta escola!');

                return redirect()->route('catalogo');
            }

            $alunos = User::where('escola_id', '=', $escola_id)->paginate($amount);

            $aplicacoes = Aplicacao::all();
            $conteudos = Conteudo::all();

            $transmissoes = CodigoTransmissao::with('aplicacao', 'conteudo')->where([['user_id', '=', $escola->user_id]])->get();

            // dd($escola);

            return view('gestao.escola-mural')->with(compact('aplicacoes', 'conteudos', 'transmissoes', 'escola', 'alunos', 'amount'));
        }

    }

    public function postarMuralEscola($escola_id, Request $request)
    {
        if (Escola::find($escola_id) == null) {
            Redirect::back()->withErrors(['Escola não encontrada!']);
        } else {
            $postagem = PostagemEscola::create([
                'escola_id' => $escola_id,
                'user_id'  => Auth::user()->id,
                'conteudo' => $request->conteudo
            ]);

            if ($request->arquivo != null) {
                $originalName = mb_strtolower($request->arquivo->getClientOriginalName(), 'utf-8');

                $fileExtension = \File::extension($request->arquivo->getClientOriginalName());
                $newFileNameArquivo = md5($request->arquivo->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

                $pathArquivo = $request->arquivo->storeAs('uploads/escolas/' . $escola_id . '/arquivos', $newFileNameArquivo, 'local');

                if (!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo))) {
                    \Session::flash('error', 'Não foi possível fazer upload de seu anexo!');
                } else {
                    $postagem->update([
                        'arquivo' => $newFileNameArquivo
                    ]);
                }
            }

            return Redirect::back()->with('message', 'Postagem enviada com sucesso!');
        }
    }

    public function postExcluirPostagem($escola_id, $idPostagem)
    {
        if (PostagemEscola::find($idPostagem) != null) {
            if (\Storage::disk('local')->has('uploads/escolas/' . $escola_id . '/arquivos/' . PostagemEscola::find($idPostagem)->arquivo)) {
                \Storage::disk('local')->delete('uploads/escolas/' . $escola_id . '/arquivos/' . PostagemEscola::find($idPostagem)->arquivo);
            }

            PostagemEscola::find($idPostagem)->delete();

            return Redirect::back()->with('message', 'Postagem excluída com sucesso!');
        } else {
            return Redirect::back()->withErrors(['Postagem não encontrada!']);
        }
    }

    public function postEnviarComentarioPostagem($escola_id, $idPostagem, Request $request)
    {
        if (Escola::find($escola_id) == null) {
            Redirect::back()->withErrors(['Escola não encontrada!']);
        } else if (PostagemEscola::find($idPostagem) == null) {
            Redirect::back()->withErrors(['Postagem não encontrada!']);
        } else {
            $comentario = ComentarioPostagemEscola::create([
                'postagem_id' => $idPostagem,
                'user_id'     => Auth::user()->id,
                'conteudo'    => $request->conteudo
            ]);

            return Redirect::back()->with('message', 'Comentário enviado com sucesso!');
        }
    }

    public function postExcluirComentarioPostagem($escola_id, $idPostagem, $idComentario)
    {
        if (ComentarioPostagemEscola::find($idPostagem) == null) {
            return Redirect::back()->withErrors(['Comentário não encontrado!']);
        } else {
            ComentarioPostagemEscola::find($idPostagem)->delete();

            return Redirect::back()->with('message', 'Comentário excluído com sucesso!');
        }
    }

    public function getArquivo($escola_id, $postagem_id)
    {
        if (Escola::find($escola_id) == null) {
            Session::flash('error', 'Escola não encontrada!');

            return redirect()->route('catalogo');
        } else {
            if (PostagemEscola::find($postagem_id) == null) {
                Session::flash('error', 'Postagem não encontrada!');

                return redirect()->route('catalogo');
            } else {
                $postagem = PostagemEscola::find($postagem_id);

                if (\Storage::disk('local')->has('uploads/escolas/' . $escola_id . '/arquivos/' . $postagem->arquivo)) {
                    return \Storage::disk('local')->download('uploads/escolas/' . $escola_id . '/arquivos/' . $postagem->arquivo);
                } else {
                    Session::flash('error', 'Arquivo não encontrado!');

                    return redirect()->route('catalogo');
                }
            }
        }
    }

    public function modoPostagem($escola_id, Request $request)
    {
        if (Escola::find($escola_id) == null)
        {
            return response()->json(['error' => 'Escola não encontrada!']);
        }
        else
        {
            if ($request->postagem_aberta === "true" || $request->postagem_aberta === true)
            {
                Escola::find($escola_id)->update([
                    'postagem_aberta' => 1
                ]);
            }
            else
            {
                Escola::find($escola_id)->update([
                    'postagem_aberta' => 0
                ]);
            }



            return response()->json(['success' => 'Modo de postagem da escola modificado com sucesso!']);
        }
    }

    // Gestao de escolas

    public function escolas()
    {
        if(Input::get('qt') == null)
            $amount = 10;
        else
            $amount = Input::get('qt');

        if(Input::get('ordem') == null)
            $ordem = "recentes";
        else
            $ordem = Input::get('ordem');

        if(Input::get('categoria') == null)
            $categoria = "";
        elseif(Input::get('categoria') == "geral")
            $categoria = "";
        else
            $categoria = Input::get('categoria');

        if($categoria != null)
        {
            if(Categoria::where('titulo', '=', $categoria)->first() != null)
            {
                $categoria = Categoria::where('titulo', '=', $categoria)->first()->id;
            }
        }

        $escolas = Escola::paginate($amount);

        foreach ($escolas as $escola)
        {
            $escola->qt_alunos = User::where([['permissao', '=', 'A'], ['escola_id', '=', $escola->id]])->count();
        }

        return view('gestao.crm.escolas')->with( compact('escolas', 'amount', 'ordem') );
    }

    public function criarEscola()
    {
        return view('criar-escola');
    }

    public function postCriarEscola(Request $request)
    {
        // dd($request);

        if($request->descricao == null)
        {
            $request->descricao = "";
        }

        $escola = Escola::create([
            'user_id' => Auth::user()->id,
            'titulo' => $request->titulo,
            'descricao' => $request->descricao
        ]);

        if($request->capa !=null)
        {
            $fileExtension = \File::extension($request->capa->getClientOriginalName());
            $newFileNameCapa =  md5( $request->capa->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

            $pathCapa = $request->capa->storeAs('escolas/capas', $newFileNameCapa, 'public_uploads');

            if(!\Storage::disk('public_uploads')->put($pathCapa, file_get_contents($request->capa)) )
            {
                \Session::flash('error', 'Ops! Não foi possivel enviar a capa.');
            }
            else
            {
                $escola->capa = $newFileNameCapa;

                $escola->save();
            }
        }

        Session::flash("message", 'Escola criada com sucesso!');

        return redirect()->route('gestao.escolas');
    }

    public function getEscola($escola_id)
    {
        $escola = Escola::find($escola_id);

        if($escola != null)
        {
            return response()->json(['success'=> 'Escola encontrada.', 'escola' => $escola]);
        }
        else
        {
            return response()->json(['error' => 'Escola não encontrada!']);
        }
    }

    public function postSalvarEscola(Request $request)
    {
        if(Escola::where([['id', '=', $request->escola_id]])->exists() != false)
        {
            $escola = Escola::where([['id', '=', $request->escola_id]])->first();

            $escola->update([
                'titulo' => $request->titulo,
                'descricao' => $request->descricao,
                'limite_alunos' => $request->limite_alunos,
                'nome_completo' => $request->nome_completo,
                'cnpj' => $request->cnpj,
                'nome_responsavel' => $request->nome_responsavel,
                'email_responsavel' => $request->email_responsavel,
                'telefone_responsavel' => $request->telefone_responsavel,
            ]);

            Session::flash("message", 'Escola atualizada com sucesso!');
        }
        else
        {
            return redirect()->back()->withErrors("Escola não encontrada!");
        }

        return redirect()->back();
    }

    public function postExcluirEscola(Request $request)
    {
        if(Escola::find($request->idEscola) != null)
        {
            if(\Storage::disk('public_uploads')->has('escolas/capas/' . Escola::find($request->idEscola)->capa))
            {
                \Storage::disk('public_uploads')->delete('escolas/capas/' . Escola::find($request->idEscola)->capa);
            }

            Escola::find($request->idEscola)->delete();

            Session::flash("message", 'Escola excluída com sucesso!');
        }
        else
        {
            return redirect()->back()->withErrors("Escola não encontrada!");
        }

        return redirect()->back();
    }

    public function painelEscola($escola_id)
    {
        $escola = Escola::find($escola_id);

        $userId = Auth::user()->id;

        if(Input::get('qtAlunos') == null)
            $amountAlunos = 10;
        else
            $amountAlunos = Input::get('qtAlunos');

        if(Input::get('qtProfessores') == null)
            $amountProfessores = 10;
        else
            $amountProfessores = Input::get('qtProfessores');

        if(Input::get('qtTurmas') == null)
            $amountTurmas = 10;
        else
            $amountTurmas = Input::get('qtTurmas');

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;


        //Relatorios gerais

        //
        // Carregar alunos da escola
        //
        $alunos = User::query();
        $alunos->when($tem_pesquisa, function ($query) {
            return $query
            ->where('name', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('email', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $alunos = $alunos
        ->with('turmas_aluno')
        ->where([['escola_id', '=', $escola_id], ['permissao', '=', 'A']])
        ->paginate($amountAlunos);

        //
        // Carregar professores da escola
        //
        $professores = User::query();
        $professores->when($tem_pesquisa, function ($query) {
            return $query
            ->where('name', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('email', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $professores = $professores
        ->with('turmas_instrutor')
        ->where([['escola_id', '=', $escola_id], ['permissao', '=', 'P']])
        ->paginate($amountProfessores);

        //
        // Carregar gestores da escola
        //
        $gestores = User::query();
        $gestores->when($tem_pesquisa, function ($query) {
            return $query
            ->where('name', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('email', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $gestores = $gestores
        ->where([['escola_id', '=', $escola_id], ['permissao', '=', 'G']])
        ->get();

        foreach($alunos as $aluno)
        {
            if(ProgressoConteudo::where('user_id', '=', $aluno->id)->count() > 0)
                $aluno->desempenho = ProgressoConteudo::where('user_id', '=', $aluno->id)->avg('progresso');
            else
                $aluno->desempenho = 0;
        }

        foreach ($professores as $professor)
        {
            if(AvaliacaoInstrutor::where('instrutor_id', '=', $professor->id)->count() > 0)
            {
                $professor->avaliacao = AvaliacaoInstrutor::where('instrutor_id', '=', $professor->id)->avg('avaliacao');
            }
            else
            {
                $professor->avaliacao = 5;
            }
        }

        $turmas = Turma::with('professor')->whereHas('professor', function($q) use ($escola_id) {
            $q->where('escola_id', '=', $escola_id);
        })->paginate($amountTurmas);

        foreach($turmas as $turma)
        {
            $turma->qt_alunos = AlunoTurma::where([['turma_id', '=', $turma->id]])->count();
        }

        $totalAlunos = count($alunos);
        $totalProfessores = count($professores);
        $totalGestores = count($gestores);
        $totalTurmas = count($turmas);

        $mediaAlunosConectados = [0, 0, 0, 0, 0];

        $nivelAprendizado = [0, 0, 0, 0, 0, 0];

        foreach (User::all() as $user)
        {
            $user->acessos = Metrica::
            where([['titulo', '=', 'Acesso na plataforma'], ['user_id', '=', $user->id]])
            ->whereHas('user', function ($q) use ($escola_id) {
                $q->where('escola_id', '=', $escola_id);
            })
            ->count();

            if($user->acessos >= 31)
            {
                $mediaAlunosConectados[0] ++;
            }
            elseif($user->acessos >= 16 && $user->acessos <= 30)
            {
                $mediaAlunosConectados[1] ++;
            }
            elseif($user->acessos >= 6 && $user->acessos <= 15)
            {
                $mediaAlunosConectados[2] ++;
            }
            elseif($user->acessos >= 1 && $user->acessos <= 5)
            {
                $mediaAlunosConectados[3] ++;
            }
            else
            {
                $mediaAlunosConectados[4] ++;
            }

            $totalAvaliacoes = AvaliacaoConteudo::
            where([['user_id', '=', $user->id]])
            ->whereHas('user', function ($q) use ($escola_id) {
                $q->where('escola_id', '=', $escola_id);
            })
            ->count();

            $totalAvaliacoesPositivas = AvaliacaoConteudo::
            where([['user_id', '=', $user->id], ['avaliacao', '=', 1]])
            ->whereHas('user', function ($q) use ($escola_id) {
                $q->where('escola_id', '=', $escola_id);
            })
            ->count();

            if($totalAvaliacoes == 0)
            {
                $nivelAprendizado[5] ++;
            }
            else
            {
                $percentualAprendizagem = ($totalAvaliacoesPositivas * 100) / $totalAvaliacoes;

                if($percentualAprendizagem >= 80)
                {
                    $nivelAprendizado[0] ++;
                }
                elseif($percentualAprendizagem >= 60 && $percentualAprendizagem <= 79)
                {
                    $nivelAprendizado[1] ++;
                }
                elseif($percentualAprendizagem >= 40 && $percentualAprendizagem <= 59)
                {
                    $nivelAprendizado[2] ++;
                }
                elseif($percentualAprendizagem >= 20 && $percentualAprendizagem <= 39)
                {
                    $nivelAprendizado[3] ++;
                }
                else//if($percentualAprendizagem >= 0 && $percentualAprendizagem <= 19)
                {
                    $nivelAprendizado[4] ++;
                }
            }
        }

        $aplicacoes = Aplicacao::with('progressos_user.user')
        ->whereHas('user', function ($q) use ($escola_id) {
            $q->where('escola_id', '=', $escola_id);
        })
        ->get();

        $conteudos = Conteudo::with('progressos_user.user')
        ->whereHas('user', function ($q) use ($escola_id) {
            $q->where('escola_id', '=', $escola_id);
        })
        ->get();

        $videos = $conteudos->filter(function ($c) { return $c->tipo == 3; });
        $slides = $conteudos->filter(function ($c) { return ($c->tipo == 4 && (strpos($c->conteudo, ".ppt") !== false || strpos($c->conteudo, ".pptx") !== false)); });
        $documentos = $conteudos->filter(function ($c) { return $c->tipo == 1 || ($c->tipo == 4 && (strpos($c->conteudo, ".ppt") == false && strpos($c->conteudo, ".pptx") == false)); });
        $apostilas = $conteudos->filter(function ($c) { return $c->tipo == 11; });

        // dd($aplicacoes);
        // dd($conteudos);

        $totalAplicacoes = count($aplicacoes);
        $totalConteudos = count($conteudos);

        $mediaAtividadesCompletas = 0;
        $somatoria = 0;
        $total = 0;

        $participativos = 0;

        foreach ($aplicacoes as $aplicacao)
        {
            foreach ($aplicacao->progressos_user as $progresso)
            {
                if($progresso->user['escola_id'] == $escola_id)
                {
                    if($progresso->progresso > 0)
                        $participativos ++;

                    if($progresso->progresso > 100)
                        $progresso->progresso = 100;

                    $somatoria ++;
                    $total += $progresso->progresso;
                }
            }
        }

        foreach ($conteudos as $conteudo)
        {
            foreach ($conteudo->progressos_user as $progresso)
            {
                if($progresso->user['escola_id'] == $escola_id)
                {
                    if($progresso->progresso > 0)
                        $participativos ++;

                    if($progresso->progresso > 100)
                        $progresso->progresso = 100;

                    $somatoria ++;
                    $total += $progresso->progresso;
                }
            }
        }

        $totalProgressos = ProgressoConteudo::count();

        if($somatoria > 0)
        {
            $mediaAtividadesCompletas = number_format($total / $somatoria, 0);

            if($participativos > 0)
            {
                $participacao = number_format( ($participativos * 100) / $participativos, 0);
            }
            else
            {
                $participacao = 0;
            }
        }
        else
        {
            $mediaAtividadesCompletas = 0;

            $participacao = 0;
        }

        // Liberação de aplicações para escola

        $liberacaoAplicacoesEscola = LiberacaoAplicacaoEscola::where('escola_id', $escola->id)->whereHas('aplicacao')->get();

        foreach ($liberacaoAplicacoesEscola as $key => $liberacao)
        {
            $liberacao->titulo = ucfirst(Aplicacao::where('id', $liberacao->aplicacao_id)->first()->titulo);
        }

        $codigosAcesso = CodigoAcessoEscola::where('escola_id', $escola->id)->get();

        return view('gestao.escola-painel')->with(compact('escola',
        'codigosAcesso', 'liberacaoAplicacoesEscola',
        'totalGestores', 'totalProfessores', 'totalProgressos',
        'mediaAtividadesCompletas', 'participacao', 'mediaAlunosConectados', 'nivelAprendizado',
        'aplicacoes', 'conteudos', 'videos', 'slides', 'documentos',
        'alunos', 'totalAlunos', 'amountAlunos',
        'turmas', 'totalTurmas', 'amountTurmas',
        'professores', 'amountProfessores', 'gestores'));
    }

    public function editarEscola($escola_id)
    {
        $escola = Escola::find($escola_id);

        if($escola == null)
        {
            return redirect()->route('gestao.escolas');
        }

        $escola->caracteristicas = json_decode($escola->caracteristicas);

        return view('gestao.editar-escola')->with( compact('escola') );
    }

}
<file_sep>/app/ConfiguracoesNotificacoesUser.php
<?php
namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class ConfiguracoesNotificacoesUser extends Model
{
    protected $table = "configuracoes_notificacoes_user";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'rcb_notif_resp_professor',
        'rcb_notif_resp_aluno',
        'rcb_notif',
    ];

    protected $attributes = [
        'rcb_notif_resp_professor' => true,
        'rcb_notif_resp_aluno' => true,
        'rcb_notif' => true,
    ];

    protected $casts = [
        'rcb_notif_resp_professor' => 'boolean',
        'rcb_notif_resp_aluno' => 'boolean',
        'rcb_notif' => 'boolean',
    ];

    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }

}
<file_sep>/app/Http/Controllers/DashboardController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use App\User;
use App\Categoria;
use App\HelperClass;
use App\Escola;

class DashboardController extends Controller
{

    public function usuarios()
    {

        if(Input::get('qt') == null)
            $amount = 10;
        else
            $amount = Input::get('qt');

        if(Input::get('pesquisa') != null)
            $pesquisa = Input::get('pesquisa');

        if(isset($pesquisa))
        {
            $usuarios = User::PermissaoNamed(
                User::where('id', 'like', '%' . $pesquisa . '%')->
                    orWhere('email', 'like', '%' . $pesquisa . '%')->
                    orWhere('name', 'like', '%' . $pesquisa . '%')->
                paginate($amount)
            );
        }
        else
        {
            $usuarios = User::PermissaoNamed(User::paginate($amount));
        }

        $escolas = Escola::orderBy('titulo')->get();

        return view('dashboard.usuarios')->with(compact('usuarios', 'escolas', 'amount'));

    }
}
<file_sep>/app/Http/Controllers/GradeAula/Alunos/GradeAulaController.php
<?php

namespace App\Http\Controllers\GradeAula\Alunos;

use App\User;
use Carbon\Carbon;
use Illuminate\Database\Query\Builder;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use App\Entities\GradeAula\GradeAula;
use Illuminate\Support\Facades\DB;


class GradeAulaController extends Controller
{

    private function getAluno()
    {
        return User::find(Auth::user()->id);
    }

    private function getTurmas()
    {
        return $turmas = $this->getAluno()->turmas_aluno;
    }

    private function getAulas($date, $turma)
    {

        $dayOfWeek = Carbon::createFromFormat('Y-m-d', $date)->dayOfWeek;
        if ($turma === "todas") {
            $turmasId = [];
            foreach ($this->getAluno()->turmas_aluno as $turma) {
                $turmasId[] = $turma->turma_id;
            }

            // Retorna as grades de aula relacionadas a todas as turmas que o aluno faz parte.
            return GradeAula::whereIn('turma_id', $turmasId)
                ->where(function ($query) use ($dayOfWeek, $date) {
                    $query->where([['recorrente', 0], ['data', $date]]);
                    $query->orWhere([['recorrente', 1], ['dia', $dayOfWeek]]);
                })->with('planos')->get();
        }

        // Retorna as grades de aula relacionada a uma turma.
        return GradeAula::where('turma_id', $turma)->where(function ($query) use ($dayOfWeek, $date) {
            $query->where([['recorrente', 0], ['data', $date]]);
            $query->orWhere([['recorrente', 1], ['dia', $dayOfWeek]]);
        })->get();
    }


    public function index($date, $turma)
    {
        $aulas = $this->getAulas($date, $turma);
        $turmas = $this->getTurmas();
        $turmaUrl = request()->segment(5);
        return view('pages.grade-aulas.alunos.index', compact('aulas', 'turmas', 'turmaUrl', 'date'));
    }
}
<file_sep>/app/ConteudoCompleto.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

use Carbon\Carbon;

class ConteudoCompleto extends Model
{    
    protected $table = 'conteudo_completo';

    //Preenchiveis
    protected $fillable = [
        'id',
        'curso_id',
        'aula_id',
        'conteudo_id',
        'user_id',
        'resposta',
        'correta',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'resposta' => null,
        'correta' => null
    ];

    public function curso()
    {
        return $this->belongsTo('App\Curso', 'curso_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/RoteiroTopico.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class RoteiroTopico extends Model
{
    protected $table = 'roteiros_topicos';

    //Preenchiveis
    protected $fillable = [
        'roteiro_id',
        'user_id',
        'status'
    ];

    public $topicosAtivos;
    public $topicosInativos;

    // Protegidos
    protected $hidden = [
    ];

    //Atributos
    protected $attributes = [
    ];

    public function topico()
    {
        return $this->belongsTo('App\Roteiro');
    } 
    
    public function topicosAtivos()
    {
        return $query::where('status', 1);
    }

    public function topicosInativos()
    {
        return $query::where('status', 0);
    }

}
<file_sep>/app/Http/Controllers/Favoritos/Api/FavoritosApiController.php
<?php

namespace App\Http\Controllers\Favoritos\Api;

use App\Entities\Favorito\Favorito;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Validator;

class FavoritosApiController extends Controller
{


    public function listar($field)
    {
        try {
            // if ($field === 'albuns')
            {
                $favoritos = Favorito::where('user_id', Auth::user()->id)
                    ->where('album_id', '!=', null)
                    ->with(['albums' => function ($query) {
                        $query->select('albums.id', 'albums.titulo', 'albums.capa as url', 'albums.descricao', 'albums.categoria', 'albums.user_id as artist', 'albums.user_id');
                    }])
                    ->select('favoritos.id', 'favoritos.user_id', 'favoritos.album_id')
                    ->get();
            }
            return response()->json($favoritos);
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao lista os favoritos", "message:" => $exception->getMessage()]);
        }
    }




    public function store(Request $request)
    {
        try {
            $field = $request->get('field');
            $check = Favorito::where([[$field, $request->get('value')], ['user_id', Auth::user()->id]])->exists();
            $name = ($field === 'album_id' ? 'álbum' : 'áudio');
            if ($check) {
                return response()->json(['error' => "Este $name já está adicionado em seus favoritos!"]);
            }
            Favorito::create([
                'user_id' => Auth::user()->id,
                $field    => $request->get('value'),
            ]);
            return response()->json("$name adicionado aos favoritos com sucesso!");

        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao adicionar o $name aos favoritos", "message:" => $exception->getMessage()]);
        }
    }




    public function destroy($id)
    {
        try {
            $favorito = Favorito::find($id);
            $favorito->delete();
            return response()->json('Removido com sucesso!');
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao adicionar aos favoritos", "message:" => $exception->getMessage()]);
        }
    }

}
<file_sep>/app/ProdutoTransacao.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class ProdutoTransacao extends Model
{
    protected $table = 'produto_transacao';

    //Preenchiveis
    protected $fillable = [
        'transacao_id',
        'user_id',
        'produto_id',
        'titulo',
        'descricao',
        'tipo',
        'valor',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'descricao' => '',
        'tipo' => '1',
    ];

    // Tipos
    // 1 = Licenças
    // 2 = Cursos

    // public function transacao()
    // {
    //     return $this->belongsTo('App\Transacao');
    // }

    public function transacao()
    {
        return $this->belongsTo('App\Transacao', 'transacao_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/Http/Controllers/AudioInteracoes/Admin/AudioInteracoesController.php
<?php

namespace App\Http\Controllers\AudioInteracoes\Admin;

use Illuminate\Support\Facades\Input;

use App\Entities\Audio\Audio;
use App\Entities\AudioInteracoes\AudioInteracoes;

use Illuminate\Http\Request;

use App\Http\Controllers\Controller;

use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;

class AudioInteracoesController extends Controller
{
    public function index(Request $request)
    {
        $audios = Audio::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $audios->when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $is_admin = strtoupper(Auth::user()->permissao) == "Z";

        $audios->when($is_admin == false, function ($query) {
            return $query->where('user_id', '=', Auth::user()->id);
        });

        $audios = $audios
        ->orderBy('id', 'DESC')
        ->get();

        return view('pages.audios-interacoes.admin.index', compact('audios'));
    }

    public function store(Request $request)
    {
        $audioInteracao = AudioInteracoes::create([
            'user_id'   => Auth::user()->id,
            'audio_id'  => $request->get('audio_id'),
            'titulo'    => $request->get('titulo'),
            'descricao' => $request->get('descricao'),
            'inicio'    => $request->get('inicio'),
            'fim'       => $request->get('fim'),
        ]);

        return redirect('gestao/audios-interacoes/'.$request->get('audio_id').'/view')->with('message', 'Interação adicionada com sucesso!');
    }

    public function view($idAudio)
    {
        $audio = Audio::find($idAudio);

        return view('pages.audios-interacoes.admin.view', compact('audio'));
    }

    public function update(Request $request, $idAudioInteracao)
    {
        $audioInteracao = AudioInteracoes::find($idAudioInteracao);

        $audioInteracao->update([
            'id'        => $idAudioInteracao,
            'audio_id'  => $request->get('audio_id'),
            'titulo'    => $request->get('titulo'),
            'descricao' => $request->get('descricao'),
            'inicio'    => $request->get('inicio'),
            'fim'       => $request->get('fim')
        ]);

        return redirect('gestao/audios-interacoes/'.$request->get('audio_id').'/view')->with('message', 'Interação atualizada com sucesso!');
    }

    public function destroy(Request $request, $idAudioInteracao)
    {
        $audioInteracao = AudioInteracoes::find($idAudioInteracao);

        if (!$audioInteracao) {
            return redirect()->back()->withErrors(['Interação não encontrada!']);
        }

        $audioInteracao->delete();

        return redirect('gestao/audios-interacoes/'.$request->get('audio_id').'/view')->with('message', 'Interação excluída com sucesso!');
    }

}
<file_sep>/app/Http/Controllers/Conquistas/Admin/ConquistasController.php
<?php

namespace App\Http\Controllers\Conquistas\Admin;


use App\Entities\Conquista\Conquista;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Input;

class ConquistasController extends Controller
{

    public function index(Request $request)
    {
        $conquistas = Conquista::orderBy('id', 'DESC')->paginate(6);

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;
        if($tem_pesquisa)
        {
            $conquistas = Conquista::where('titulo', 'like', '%' . Input::get('pesquisa') . '%')->paginate(6);
        }

        return view('pages.conquistas.admin.index', compact('conquistas'));
    }

    public function store(Request $request)
    {
        $this->validate($request, [
            'titulo'    => 'required'
        ]);
        $values = $request->all();
        $values['user_id'] = Auth::user()->id;

        Conquista::create($values);
        return redirect()->route('gestao.conquistas.listar')->with('message', 'Conquista cadastrado com sucesso!');
    }

    public function fetch($id, Request $request)
    {
        $conquista = Conquista::find($id);

        return $conquista->toJson();
    }        

    public function update($id, Request $request)
    {
        $this->validate($request, [
            'titulo'    => 'required'
        ]);
        $values = $request->all();
        Conquista::find($id)->update($values);

        return redirect()->route('gestao.conquistas.listar')->with('message', 'Conquista atualizado com sucesso!');
    }


    public function delete($id)
    {
        Conquista::find($id)->delete();

        return redirect()->route('gestao.conquistas.listar')->with('message', 'Conquista excluído com sucesso!');
    }

}
<file_sep>/pull.sh
git pull
php artisan migrate
php artisan cache:clear
php artisan config:clear
php artisan view:clear
php artisan route:clear
# php artisan route:cache
echo 'Pull finished.'
<file_sep>/app/Http/Controllers/CanalProfessor/CanalProfessorController.php
<?php

namespace App\Http\Controllers\CanalProfessor;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\User;

use App\AvaliacaoInstrutor;
use App\DuvidaProfessor;

use App\Escola;
use App\Conteudo;
use App\Metrica;
use App\ComentarioDuvidaProfessor;
use App\AlunoTurma;
use App\Turma;

use App\Aplicacao;
use App\Categoria;

use App\Curso;
use App\Aula;
use App\ConteudoAula;
use App\Matricula;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

use App\Http\Controllers\Controller;

class CanalProfessorController extends Controller
{

    public function index($idProfessor)
    {
        $professor = User::find($idProfessor);

        $podcasts = Conteudo::where('user_id', $idProfessor)
            ->where('tipo', 2)->get();
        $transmissoes = Conteudo::where('user_id', $idProfessor)
            ->where('tipo', 5)->get();

        //echo '<pre>'; print_r($conteudos); die;

        return view('pages.canal_professor.index', compact('podcasts', 'transmissoes', 'professor'));
    }

    public function biblioteca($idProfessor)
    {
        $professor = User::find($idProfessor);

        $conteudos = Conteudo::where('user_id', $idProfessor)->get();

        $aplicacoes = Aplicacao::where('user_id', $idProfessor)->get();

        $videos = $conteudos->filter(function ($c) {
            return $c->tipo == 3;
        });

        $slides = $conteudos->filter(function ($c) {
            return ($c->tipo == 4 && (strpos($c->conteudo, ".ppt") !== false || strpos($c->conteudo, ".pptx") !== false));
        });

        $documentos = $conteudos->filter(function ($c) {
            return $c->tipo == 1 || ($c->tipo == 4 && (strpos($c->conteudo, ".ppt") == false && strpos($c->conteudo, ".pptx") == false));
        });

        $apostilas = $conteudos->filter(function ($c) {
            return $c->tipo == 11;
        });

        return view('pages.canal_professor.biblioteca')->with(compact('conteudos', 'videos', 'slides', 'apostilas', 'documentos', 'aplicacoes', 'professor'));
    }

    public function avaliacoes($idProfessor)
    {
        $professor = User::find($idProfessor);

        $avaliacoes = DB::table('avaliacoes_instrutor')
            ->join('users', 'avaliacoes_instrutor.user_id', '=', 'users.id')
            ->select(DB::raw('users.id as id,
                users.name as nome,
                users.img_perfil as img_perfil,
                avaliacoes_instrutor.descricao as avaliacao,
                avaliacoes_instrutor.avaliacao as estrelas'))
            ->where('avaliacoes_instrutor.instrutor_id', '=', $idProfessor)
            ->get();

        return view('pages.canal_professor.avaliacoes', compact('avaliacoes', 'professor'));
    }

    public function duvidas($idProfessor)
    {
        $professor = User::with('escola')->find($idProfessor);

        if($professor == null)
        {
            return redirect()->back()->withErrors("Professor não encontrado!");
        }
        else if(strtoupper($professor->permissao) != "P" && strtoupper($professor->permissao) != "G" && strtoupper($professor->permissao) != "Z")
        {
            return redirect()->back()->withErrors("Professor não encontrado!");
        }

        if(AvaliacaoInstrutor::where('instrutor_id', '=', $idProfessor)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $idProfessor)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $duvidas = DuvidaProfessor::where([['professor_id', '=', $idProfessor]])
        ->orderBy('status', 'asc')
        ->orderBy('created_at', 'desc')
        ->get();
        // ->sortBy('status');

        foreach ($duvidas as $duvida)
        {
            $duvida->qt_comentarios = ComentarioDuvidaProfessor::where([['duvida_id', '=', $duvida->id]])->count();
        }

        // dd($duvidas);

        return view('pages.canal_professor.duvidas')->with(compact('duvidas', 'professor', 'avaliacaoInstrutor'));
    }

    public function duvida($idProfessor, $idDuvida)
    {
        $duvida = DuvidaProfessor::with('professor', 'user', 'comentarios')->has('professor')->has('user')->find($idDuvida);

        if($duvida == null)
        {
            return redirect()->route('professor.duvidas', $idProfessor)->withErrors("Dúvida não encontrada!");
        }

        if(AvaliacaoInstrutor::where('instrutor_id', '=', $duvida->professor->id)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $duvida->professor->id)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $turma = Turma::where([['user_id', '=', Auth::user()->id]])->first();

        return view('pages.canal_professor.duvida-respostas')->with(compact('turma', 'duvida', 'avaliacaoInstrutor'));
    }

}
<file_sep>/app/TopicoCurso.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class TopicoCurso extends Model
{
    protected $table = 'topico_curso';

    //Preenchiveis
    protected $fillable = [
        'curso_id',
        'user_id',
        'titulo',
        'descricao',
        'status'
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'descricao' => '',
        'status' => 0
    ];

    public function comentarios()
    {
        return $this->hasMany('App\ComentarioTopicoCurso', 'topico_curso_id');
    }

    public function getUltimoComentarioAttribute()
    {
        return \App\ComentarioTopicoCurso::where([['topico_curso_id', '=', $this->id]])->with('user')->first();
    }

    public function getVisualizacoesAttribute()
    {
        return \App\Metrica::where('titulo', '=', 'Visualização tópico - ' . $this->id)->pluck('user_id')->unique('user_id')->count();
    }

    public function curso()
    {
        return $this->belongsTo('App\Curso', 'curso_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/database/migrations/2019_08_08_111945_create_grade_aulas_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateGradeAulasTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('grade_aulas', function(Blueprint $table)
		{
			$table->increments('id');
			$table->integer('user_id');
			$table->integer('turma_id');
			$table->string('titulo');
			$table->text('descricao', 65535)->nullable();
			$table->date('data')->nullable();
			$table->dateTime('data_inicial');
			$table->time('hora_inicial')->nullable();
			$table->dateTime('data_final');
			$table->time('hora_final')->nullable();
			$table->boolean('recorrente')->nullable();
			$table->integer('dia')->nullable();
			$table->string('cor', 100)->nullable();
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('grade_aulas');
	}

}
<file_sep>/app/Entities/ConfiguracoesGamificacao/ConfiguracoesGamificacao.php
<?php

namespace App\Entities\ConfiguracoesGamificacao;

use App\User;

use Illuminate\Database\Eloquent\Model;

class ConfiguracoesGamificacao extends Model
{
    protected $table = "configuracoes_gamificacao";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'escola_id',
        'login_ativo',
        'login_xp',
        'conclusao_conteudo_ativo',
        'conclusao_conteudo_xp',
        'conclusao_aula_ativo',
        'conclusao_aula_xp',
        'conclusao_curso_ativo',
        'conclusao_curso_xp',
        'conclusao_teste_ativo',
        'conclusao_teste_xp',
        'topico_ativo',
        'topico_xp',
        'comentario_ativo',
        'comentario_xp',
        'level_up_curso_ativo',
        'level_up_curso',
        'level_up_conquista_ativo',
        'level_up_conquista',
        'formula_level_ativo',
        'formula_level',
    ];

    protected $attributes = [
        'login_ativo' => false,
        'conclusao_conteudo_ativo' => false,
        'conclusao_aula_ativo' => false,
        'conclusao_curso_ativo' => false,
        'conclusao_teste_ativo' => false,
        'topico_ativo' => false,
        'comentario_ativo' => false,
        'level_up_curso_ativo' => false,
        'level_up_conquista_ativo' => false,
        'formula_level_ativo' => false,
    ];

    protected $casts = [
        'login_ativo' => 'boolean',
        'conclusao_conteudo_ativo' => 'boolean',
        'conclusao_aula_ativo' => 'boolean',
        'conclusao_curso_ativo' => 'boolean',
        'conclusao_teste_ativo' => 'boolean',
        'topico_ativo' => 'boolean',
        'comentario_ativo' => 'boolean',
        'level_up_curso_ativo' => 'boolean',
        'level_up_conquista_ativo' => 'boolean',
        'formula_level_ativo' => 'boolean',
    ];

    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }

    public function escola()
    {
        return $this->belongsTo('AppEscola', 'user_id');
    }

}
<file_sep>/database/migrations/2019_08_08_111945_create_transacoes_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateTransacoesTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('transacoes', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->string('referencia_id')->nullable();
			$table->integer('user_id');
			$table->float('sub_total', 10, 0);
			$table->float('adicional', 10, 0)->nullable();
			$table->float('desconto', 10, 0)->nullable();
			$table->float('frete', 10, 0)->nullable();
			$table->float('total', 10, 0);
			$table->integer('status');
			$table->string('metodo');
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('transacoes');
	}

}
<file_sep>/app/Http/Controllers/UserController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Redirect;
use Session;
use Auth;
use Mail;

use App\User;
use App\ResetToken;
use App\EnderecoUser;
use App\Escola;

class UserController extends Controller
{
    public function postNovo(Request $request)
    {
        if (User::where('email', '=', $request->email)->first() != null)
        {
            \Session::flash('warning', 'Este email já está cadastrado!');
        }
        else
        {
            // dd($request->all());

            $user = User::create([
                'name'             => $request->name,
                'email'            => $request->email,
                'password'         => \Hash::make('<PASSWORD>'),
                'ultima_atividade' => date("Y-m-d H:i:s"),
            ]);

            if($request->has('escola_id'))
            {
                if(Escola::find($request->escola_id))
                {
                    $user->update([
                        'escola_id' => $request->escola_id
                    ]);
                }
            }

            if($request->has('permissao'))
            {
                if(strtoupper($request->permissao) == "Z")
                {
                    $user->update([
                        'permissao' => "Z"
                    ]);
                }
                else if(strtoupper($request->permissao) == "E")
                {
                    $user->update([
                        'permissao' => "E"
                    ]);
                }
                else if(strtoupper($request->permissao) == "G")
                {
                    $user->update([
                        'permissao' => "G"
                    ]);
                }
                else if(strtoupper($request->permissao) == "P")
                {
                    $user->update([
                        'permissao' => "P"
                    ]);
                }
                else
                {
                    $user->update([
                        'permissao' => "A"
                    ]);
                }
            }

            \Session::flash('success', 'Usuário criada com sucesso, a senha será enviada para o endereço de email!');
        }

        // return redirect()->route('dashboard.usuarios');
        return redirect()->back();
    }

    public function perfilIncompleto()
    {
        $user = Auth::user();

        if (EnderecoUser::find($user->id) != null && $user->telefone != '' && $user->cpf != '' && $user->rg != '' && $user->nome_completo != '') {
            return redirect()->route('catalogo');
        }

        $endereco = EnderecoUser::find($user->id);

        return view('auth.perfil-incompleto')->with(compact('endereco'));
    }

    public function postPerfilIncompleto(Request $request)
    {
        $request->data_nascimento = str_replace("/", "-", $request->data_nascimento);

        $user = Auth::user()->update([
            "nome_completo"   => $request->nome_completo,
            "data_nascimento" => date("Y-m-d", strtotime($request->data_nascimento)),
            "cpf"             => $request->cpf,
            "rg"              => $request->rg,
            "telefone"        => $request->telefone,
            "genero"          => $request->genero,
            "completo"        => true,
        ]);

        if ($request->numero_complemento == null)
            $request->numero_complemento = "";

        $endereco = EnderecoUser::updateOrCreate(
            ['user_id' => Auth::user()->id],
            [
                'user_id'            => Auth::user()->id,
                "cep"                => $request->cep,
                "uf"                 => $request->uf,
                "cidade"             => $request->cidade,
                "bairro"             => $request->bairro,
                "logradouro"         => $request->logradouro,
                "numero_complemento" => $request->numero_complemento,
            ]
        );

        return redirect()->route('catalogo');
    }

    public function getUsuario($idUsuario)
    {

        if (User::find($idUsuario) != null) {
            $usuario = User::find($idUsuario);

            return response()->json(['success' => 'Usuário encontrado.', 'user' => json_encode($usuario)]);
        } else {
            return response()->json(['error' => 'Usuário não encontrado!']);
        }

    }

    public function update(Request $request)
    {
        if (User::find($request->id) != null) {
            $usuario = User::find($request->id);

            $usuario->name = $request->name;
            $usuario->email = $request->email;

            if (strrpos(mb_strtoupper(\Auth::user()->permissao, 'UTF-8'), "Z") !== false) {
                $usuario->permissao = $request->permissao;
            }

            $usuario->save();

            return Redirect::back()->with('message', 'Usuario atualizado com sucesso!');
        } else {
            return Redirect::back()->withErrors(['Usuario atualizado não encontrada!']);
        }

        // return redirect()->route('dashboard.usuarios');
        return redirect()->back();

    }

    public function delete($idUsuario)
    {
        if (strrpos(mb_strtoupper(\Auth::user()->permissao, 'UTF-8'), "Z") === false) {
            return response()->json(['error' => 'Você não tem permissão para deletar este item, consulte o administrador!']);
        }

        if ($idUsuario == \Auth::id()) {
            return response()->json(['error' => 'Você não pode deletar a si mesmo!']);
        }

        if (User::find($idUsuario) != null) {
            $user = User::find($idUsuario);

            $user->delete();

            return response()->json(['success' => 'Usuário deletado com sucesso!']);
        } else {
            return response()->json(['error' => 'Usuário não encontrado!']);
        }

    }

    public function imagemPerfil($idUsuario)
    {

        $user = User::find($idUsuario);

        if ($user == null) {
            return \Storage::disk('public_images')->response('default-user.jpg');
            // return env('APP_URL') . '/images/default-user.jpg';
        } elseif ($user->img_perfil == null || $user->img_perfil == "") {
            return \Storage::disk('public_images')->response('default-user.jpg');
            // return env('APP_URL') . '/images/default-user.jpg';
        } else {
            if (\Storage::disk('local')->has('uploads/usuarios/perfil/' . $user->img_perfil)) {
                return \Storage::disk('local')->response('uploads/usuarios/perfil/' . $user->img_perfil);
            } else {
                $user->img_perfil = '';
                $user->save();

                return \Storage::disk('public_images')->response('default-user.jpg');
            }
        }

    }

    public function esqueciSenha()
    {
        if (\Auth::check()) {
            return redirect()->route('catalogo');
        }

        return view('user.esqueci-senha');
    }

    public function postEsqueciSenha(Request $request)
    {
        // dd($request);

        $newToken = md5(uniqid(time(), true));

        if (ResetToken::where('email', '=', $request->email)->first() != null) {
            $resetToken = ResetToken::where('email', '=', $request->email)->first();

            $resetToken->token = $newToken;
            $resetToken->created_at = date('Y-m-d H:i:s');

            $resetToken->save();
        } else {
            ResetToken::create([
                "email"      => $request->email,
                "token"      => $newToken,
                "created_at" => date('Y-m-d H:i:s'),
            ]);
        }

        $userEmail = $request->email;
        $userName = ucwords(User::where('email', '=', $request->email)->first()->name);

        // dd($newToken);

        $data = [
            'email' => $userEmail,
            'name'  => $userName,
            'token' => $newToken
        ];

        Mail::send('mail.reset-email', $data, function ($message) use ($data) {
            $message->from('<EMAIL>', 'Sup<NAME>');

            $message->to($data['email'], $data['name'])->
            subject('Jean Piaget - Link para resetar senha');
        });

        \Session::flash('message', 'Enviamos para seu email um link para resetar sua senha, verifique em sua caixa de entrada!');

        return redirect()->route('home');

        // return redirect()->route('catalogo');

        // return view('user.esqueci-senha');
    }

    public function resetarSenha($token)
    {
        if (\Auth::check()) {

            Session::flush();
            // return redirect()->route('catalogo');
        }

        return view('user.resetar-senha')->with(compact('token'));
    }

    public function postResetarSenha(Request $request)
    {
        $validatedData = $request->validate([
            'email'    => 'required|string|email|max:255|exists:users',
            'password' => '<PASSWORD>',
            // 'password_confirmation' => '<PASSWORD>',
        ]);

        if (strlen($request->password) < 6) {
            \Session::flash('warning', 'A sua nova senha deve ter no mínimo 6 caracteres!');

            return redirect()->back();
        }

        if ($request->password != $request->password_confirmation) {
            \Session::flash('warning', 'A senha de confirmação deve ser idêntica a sua nova senha!');

            return redirect()->back();
        }

        if (User::where('email', '=', $request->email)->first() == null) {
            \Session::flash('warning', 'O email inserido é inválido!');

            return redirect()->back();
        }

        if (ResetToken::where([['email', '=', $request->email], ['token', '=', $request->token]])->first() == null) {
            return redirect()->back()->withErrors('Link para troca de senha inválido, tente fazer uma nova solicitação!');
        }

        $resetToken = ResetToken::where([['email', '=', $request->email], ['token', '=', $request->token]])->first();

        $start_date = new \DateTime(date('Y-m-d H:i:s'));
        $since_start = $start_date->diff(new \DateTime($resetToken->created_at));

        if ($since_start->days === false || $since_start->y > 0 || $since_start->m > 0 || $since_start->d > 0 || $since_start->h > 0 || $since_start->i > 15) {
            ResetToken::where([['email', '=', $request->email], ['token', '=', $request->token]])->delete();

            return redirect()->back()->withErrors('Link para troca de senha expirado, tente fazer uma nova solicitação!');
        }

        $user = User::where('email', '=', $request->email)->first();

        $user->password = \Hash::make($request->password);

        $user->save();

        \Auth::loginUsingId($user->id);

        ResetToken::where([['email', '=', $request->email], ['token', '=', $request->token]])->delete();

        \Session::flash('message', 'Senha alterada com sucesso!');

        return redirect()->route('catalogo');

    }
}


<file_sep>/app/Http/Controllers/Agenda/AgendaController.php
<?php

namespace App\Http\Controllers\Agenda;

use App\Entities\Agenda\Agenda;
use App\Entities\GradeAula\GradeAula;
use App\Turma;
use App\User;
use Carbon\Carbon;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use MaddHatter\LaravelFullcalendar\Facades\Calendar;

class AgendaController extends Controller
{

    private function getAgendaPessoal()
    {
        $agendaPessoal = [];

        $dataAgendaPessoal = Agenda::where('user_id', Auth::user()->id)->get();

        foreach ($dataAgendaPessoal as $key => $value) {
            $agendaPessoal[] = Calendar::event(
                $value->titulo,
                false,
                $value->data_inicial,
                $value->data_final,
                $value->id,
                [
                    'color' => "$value->cor",
                    'textColor' => '#FFFFFF',
                    'description' => $value->descricao,
                ]
            );
        }
        return $agendaPessoal;
    }


    private function getCalendars($idTurma = null, $pessoal = false, $mesclar = false)
    {
        $opts = [
            'firstDay' => 1, // inicia na segunda
            'columnFormat' => 'ddd D',
            'allDaySlot' => false,
            'defaultView' => 'agendaWeek',
            'slotLabelFormat' => 'HH:mm',
            'locale' => 'pt-br',
            'contentHeight' => 'auto'
        ];

        $setCallbacks = [
            'dayClick' => 'function(date){
                $(".modal-body #dateCalendar").val( date.format("DD/MM/YYYY HH:mm") );
                $(".modal-body #dateCalendarInput").val( date.format("DD/MM/YYYY") );
                $(".modal-body #hourCalendarInput").val( date.format("HH:mm") );
                $("#novaAgenda").modal("show");
            }',
            'eventClick' => 'function(event, date) {
                $(".modal-body #idCalendar").val( event.id );
                $(".modal-body #dateCalendarEditInput").val(event.start.format("DD/MM/YYYY"));
                $(".modal-body #hourCalendarInput").val(event.start.format("HH:mm"));
                $(".modal-body #tituloCalendar").val( event.title );
                $(".modal-body #descricaoCalendar").val( event.description );
                $(".modal-body #dateShowCalendar").html( event.start.format("DD/MM/YYYY HH:mm") );
                $(".modal-body #removeAgenda").attr("data-id", event.id);
                $("#editaAgenda").modal("show");
            }'
        ];


        if ($pessoal == true) {
            $opts['hiddenDays'] = [0];
            $opts['minTime'] = '05:00:00';
            $opts['maxTime'] = '23:00:00';
            $opts['slotDuration'] = '01:00:00';

            $calendar = Calendar::addEvents($this->getAgendaPessoal())->setOptions($opts)->setCallbacks($setCallbacks);
        }

        if ($idTurma !== null) {
            $opts['minTime'] = '05:00:00';
            $opts['maxTime'] = '23:00:00';
            $opts['slotDuration'] = '01:00:00';
            $setCallbacks = [];
            $agendaTurma = [];

            if (is_array($idTurma)) {
                // grade de aulas relacionada a mais de uma turma
                $dataTurma = GradeAula::whereIn('turma_id', $idTurma)->get();
            } else {
                // grade de aulas relacionadas a uma turma
                $dataTurma = GradeAula::where('turma_id', $idTurma)->get();
            }

            foreach ($dataTurma as $key => $value) {
                $extras = [
                    'color' => "$value->cor",
                    'textColor' => '#FFFFFF',
                    'description' => $value->descricao,
                    'dow' => [$value->dia],
                    'ranges' => [$value->dia => ['start' => "$value->data_inicial", 'end' => '']]
                ];
                if ($value->recorrente == 0) {
                    unset($extras['dow']);
                    unset($extras['ranges']);
                }
                $agendaTurma[] = Calendar::event(
                    $value->titulo,
                    false,
                    $value->data_inicial,
                    $value->data_final,
                    $value->id,
                    $extras
                );
            }
            if ($mesclar == 'true') {
                $calendar = Calendar::addEvents($agendaTurma)->addEvents($this->getAgendaPessoal())->setOptions($opts)->setCallbacks($setCallbacks);
            } else {
                $calendar = Calendar::addEvents($agendaTurma)->setOptions($opts)->setCallbacks($setCallbacks);
            }

        }

        return $calendar;
    }

    private function getTurmas()
    {
        $aluno = User::find(Auth::user()->id);
        return $turmas = $aluno->turmas_aluno;
    }

    public function index()
    {
        $turmas = $this->getTurmas();

        // lista apenas registros da agenda pessoal
        $calendar = $this->getCalendars(null, true);

        return view('pages.agenda.index', compact('calendar', 'turmas'));
    }


    public function filterCalendar($idTurma, $mesclar)
    {
        $turmas = $this->getTurmas();

        /*
         * Verifica se o usuario clicou em todas as turmas
         * Recupera os ids das turmas relacionada ao usuário
         */
        if ($idTurma == 'todas') {
            $idsTurmas = [];
            foreach ($turmas as $turma) {
                $idsTurmas[] = $turma->turma_id;
            }
            $calendar = $this->getCalendars($idsTurmas, false, $mesclar);
            $nomeTurma = "Todas as turmas";
        }

        if ($idTurma !== 'todas') {
            $calendar = $this->getCalendars($idTurma, false, $mesclar);
            $nomeTurma = Turma::find($idTurma)->titulo;
        }


        return view('pages.agenda.index', compact('calendar', 'turmas', 'nomeTurma', 'idTurma'));
    }


    public function store(Request $request)
    {
        $startDate = Carbon::createFromFormat('d/m/Y', $request->get('date'))->format('Y-m-d') . ' ' . $request->get('hour');
        $endDate = Carbon::parse($startDate)->addHours(1)->format('Y-m-d H:s');
        Agenda::create([
            'data_inicial' => $startDate,
            'data_final' => $endDate,
            'titulo' => $request->get('titulo'),
            'descricao' => $request->get('descricao'),
            'cor' => $request->get('cor'),
            'user_id' => Auth::user()->id
        ]);
        return redirect()->route('agenda.index')->with('message', 'Agenda cadastrada com sucesso!');
    }


    public function update(Request $request)
    {
        $startDate = Carbon::createFromFormat('d/m/Y', $request->get('date'))->format('Y-m-d') . ' ' . $request->get('hour');
        $endDate = Carbon::parse($startDate)->addHours(1)->format('Y-m-d H:s');

        Agenda::find($request->get('id'))->update([
            'data_inicial' => $startDate,
            'data_final' => $endDate,
            'titulo' => $request->get('titulo'),
            'descricao' => $request->get('descricao'),
            'cor' => (!empty($request->get('cor')) ? $request->get('cor') : Agenda::find($request->get('id'))->cor)
        ]);
        return redirect()->route('agenda.index')->with('message', 'Agenda atualizada com sucesso!');
    }


    public function delete(Request $request)
    {
        Agenda::find($request->get('idAgenda'))->delete();
        return redirect()->route('agenda.index')->with('message', 'Registro excluído com sucesso!');

    }

}
<file_sep>/app/ComentarioTopicoCurso.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class ComentarioTopicoCurso extends Model
{
    protected $table = 'comentario_topico_curso';

    //Preenchiveis
    protected $fillable = [
        'topico_curso_id',
        'user_id',
        'conteudo',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
    ];

    public function topico()
    {
        return $this->belongsTo('App\TopicoCurso', 'topico_curso_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/resources/js/app.js
// require('./pages/gestao/turmas/mural')

// require('../../node_modules/@fortawesome/fontawesome-pro/js/all')

// import fontawesome from '../../node_modules/@fortawesome/fontawesome-pro/js/all';

// fontawesome.config = { autoReplaceSvg: false }

// window.FontAwesomeConfig = { autoReplaceSvg: false }

require('./pages/gestao/audios-interacoes/admin/viewAudioInteracoes')
require('./pages/roteiros/admin/indexRoteiros')

console.log("Hello world from app.js!");

$('form').submit(function(){
    $(':submit', this)
      .text('Enviando...').val('Enviando...')
      .attr('disabled', 'disabled');
    return true;
});

window.checarPreenchimento = function (elemento)
{
    var preenchido = true;

    var primeiro = null;

    $(elemento).find(':input[required], :input.required').each(function() {

        if ($(this).val() == "" || $(this).val() == null)
        {
            $(this).addClass('is-invalid');

            $(this).append('<p class="campo-obrigatorio">Campo obrigatório*</p>');

            if (primeiro == null)
            {
                primeiro = this;
            }

            preenchido = false;
        }
        else
        {
            if ($(this).hasClass('is-invalid'))
            {
                $(this).removeClass('is-invalid');
            }

            $(this).find('.campo-obrigatorio').remove();
        }

        if (primeiro != null)
        {
            $(primeiro).focus();
        }
    });

    return preenchido;
}
<file_sep>/app/Entities/Album/AlbumAudio.php
<?php

namespace App\Entities\Album;

use App\User;
use Illuminate\Database\Eloquent\Model;

class AlbumAudio extends Model
{
    protected $table = "album_audios";

    //Preenchiveis
    protected $fillable = [
        'album_id',
        'audio_id'
    ];

}
<file_sep>/app/Http/Controllers/TurmaController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;
use Redirect;
use Session;
// use Request;

use App\Entities\GradeAula\GradeAula;
use MaddHatter\LaravelFullcalendar\Facades\Calendar;

use App\Escola;
use App\User;
use App\Turma;
use App\AlunoTurma;
use App\PostagemTurma;
use App\ComentarioPostagemTurma;
use App\Aplicacao;
use App\Conteudo;
use App\CodigoTransmissao;

class TurmaController extends Controller
{


    public function index()
    {
        if (strtoupper(Auth::user()->permissao) == "G") {
            $escola = Escola::where('user_id', '=', Auth::user()->id)->first();
        }

        if (!isset($escola)) {
            $escola = Escola::find(1);
        } elseif ($escola == null) {
            $escola = Escola::find(1);
        }

        $escola->caracteristicas = json_decode($escola->caracteristicas);

        if (\Request::is('gestao/turmas')) {
            if (strtoupper(Auth::user()->permissao) == "Z") {
                $turmas = Turma::with('user')->get();
            } elseif (strtoupper(Auth::user()->permissao) == "G") {
                $turmas = Turma::with('professor')->whereHas('professor', function ($q) {
                    $q->where('escola_id', '=', Auth::user()->escola_id);
                })->get();
            } elseif (strtoupper(Auth::user()->permissao) == "P") {
                $turmas = Turma::with('professor')->where('user_id', '=', Auth::user()->id)->get();
            }
        } else {
            $turmas = collect();

            foreach (AlunoTurma::where('user_id', '=', Auth::user()->id)->get() as $turma) {
                if (Turma::find($turma->turma_id) != null) {
                    $turmas->push(Turma::with('user')->find($turma->turma_id));
                }
            }
        }

        foreach ($turmas as $turma) {
            $turma->qt_alunos = AlunoTurma::where('turma_id', '=', $turma->id)->count();
        }

        return view('gestao.turmas')->with(compact('escola', 'turmas'));
    }


    public function gradeAulas($idTurma)
    {
        $events = [];
        $data = GradeAula::where('turma_id', $idTurma)->get();
        if ($data->count()) {
            foreach ($data as $key => $value) {
                $opts = [
                    'color'       => "$value->cor",
                    'textColor'   => '#FFFFFF',
                    'description' => $value->descricao,
                    'dow'         => [$value->dia],
                    'ranges'      => [$value->dia => ['start' => "$value->data_inicial", 'end' => '2020-01-01']]
                ];

                if ($value->recorrente == 0)
                {
                    unset($opts['dow']);
                    unset($opts['ranges']);
                }

                $events[] = Calendar::event(
                    $value->titulo,
                    false,
                    $value->data_inicial,
                    $value->data_final,
                    null,
                    $opts
                );
            }
        }

        $calendar = Calendar::addEvents($events)->setOptions([
            'columnFormat'    => 'ddd D',
            'allDaySlot'      => false,
            'defaultView'     => 'agendaWeek',
            'slotLabelFormat' => 'HH:mm',
            'minTime'         => '06:00:00',
            'maxTime'         => '24:00:00',
            'slotDuration'    => '01:00:00',
            'locale'          => 'pt-br',
            'contentHeight'   => 'auto',
            'firstDay'        => 1, // inicia na segunda
        ]);

        if (Turma::find($idTurma) == null)
        {
            Redirect::back()->withErrors(['Turma não encontrada!']);
        }
        else
        {
            $turma = Turma::with('professor', 'postagens_comentarios', 'escola')->find($idTurma);

            if (strpos(Auth::user()->permissao, "G") === false && strpos(Auth::user()->permissao, "Z") === false && $turma->user_id != Auth::user()->id && (AlunoTurma::where([['turma_id', '=', $idTurma], ['user_id', '=', Auth::user()->id]])->first() == null)) {
                Session::flash('error', 'Você não faz parte desta turma!');

                return redirect()->route('catalogo');
            }

            return view('gestao.turma-mural-grade')->with(compact('turma', 'calendar'));
        }
    }


    public function postNovaTurma(Request $request)
    {
        if (isset($request->descricao)) {
            if ($request->descricao == null)
                $request->descricao = "";
        } else {
            $request->descricao = "";
        }

        Turma::create([
            'user_id'   => Auth::user()->id,
            'titulo'    => $request->titulo,
            'descricao' => $request->descricao
        ]);

        return Redirect::back()->with('message', 'Turma criada com sucesso!');

    }

    public function postExcluirTurma(Request $request)
    {
        if (Turma::find($request->idTurma) == null) {
            Redirect::back()->withErrors(['Turma não encontrada!']);
        } else {
            Turma::find($request->idTurma)->delete();
            AlunoTurma::where('turma_id', '=', $request->idTurma)->delete();
            PostagemTurma::where('turma_id', '=', $request->idTurma)->delete();

            return Redirect::back()->with('message', 'Turma excluída com sucesso!');
        }
    }

    public function postSairTurma(Request $request)
    {
        if (Turma::find($request->idTurma) == null) {
            Redirect::back()->withErrors(['Turma não encontrada!']);
        } else {
            AlunoTurma::where([['turma_id', '=', $request->idTurma], ['user_id', '=', Auth::user()->id]])->delete();

            // return redirect()->route('catalogo');
            return Redirect::back()->with('message', 'Turma deixada com sucesso!');
        }
    }

    public function postConvidarAlunos($idTurma, Request $request)
    {
        $count = 0;
        // dd($request);
        for ($i = 0; $i < 10; $i++) {
            if ($request->get('email_aluno' . ($i + 1)) == null) {
                continue;
            }

            if ($request->has('email_aluno' . ($i + 1)) == false) {
                break;
            }

            $email_aluno = $request->get('email_aluno' . ($i + 1));

            if (User::where('email', '=', $email_aluno)->first() != null) {
                if (AlunoTurma::where([['turma_id', '=', $idTurma], ['user_id', '=', User::where('email', '=', $email_aluno)->first()->id]])->first() == null) {
                    AlunoTurma::create([
                        'turma_id' => $idTurma,
                        'user_id'  => User::where('email', '=', $email_aluno)->first()->id
                    ]);

                    $count++;
                }
            }
        }

        return Redirect::back()->with('message', $count . ' aluno' . ($count != 1 ? 's' : '') . ' convidado' . ($count != 1 ? 's' : '') . ' com sucesso!');
    }

    public function removerAluno($idTurma, $idAluno)
    {
        if (Turma::find($idTurma) == null) {
            return response()->json(['error' => 'Turma não encontrada!']);
        } else {
            if (AlunoTurma::where([['turma_id', '=', $idTurma], ['user_id', '=', $idAluno]])->first() != null) {
                AlunoTurma::where([['turma_id', '=', $idTurma], ['user_id', '=', $idAluno]])->delete();

                return response()->json(['success' => 'Aluno removido com sucesso!']);
            } else {
                return response()->json(['error' => 'Aluno não encontrado!']);
            }

        }
    }

    public function muralTurma($idTurma)
    {
        if (Input::get('qt') == null)
        {
            $amount = 10;
        }
        else
        {
            $amount = Input::get('qt');
        }

        if (Turma::find($idTurma) == null)
        {
            Redirect::back()->withErrors(['Turma não encontrada!']);
        }
        else
        {
            $turma = Turma::with('professor', 'postagens_comentarios', 'escola')->find($idTurma);

            if (strpos(Auth::user()->permissao, "G") === false && strpos(Auth::user()->permissao, "Z") === false && $turma->user_id != Auth::user()->id && (AlunoTurma::where([['turma_id', '=', $idTurma], ['user_id', '=', Auth::user()->id]])->first() == null)) {
                Session::flash('error', 'Você não faz parte desta turma!');

                return redirect()->route('catalogo');
            }

            if (strpos(Auth::user()->permissao, "Z") !== false || $turma->user_id == Auth::user()->id)
            {
                if (md5($turma->id . $turma->created_at) != $turma->codigo_convite)
                {
                    $newCodigo = md5($turma->id . $turma->created_at);

                    $turma->update([
                        'codigo_convite' => $newCodigo,
                    ]);
                }
            }

            $alunos = AlunoTurma::with('user')->whereHas('user')->where('turma_id', '=', $idTurma)->paginate($amount);

            $aplicacoes = Aplicacao::all();
            $conteudos = Conteudo::all();

            $transmissoes = CodigoTransmissao::with('aplicacao', 'conteudo')->where([['user_id', '=', $turma->user_id]])->get();

            // dd($turma);

            return view('gestao.turma-mural')->with(compact('aplicacoes', 'conteudos', 'transmissoes', 'turma', 'alunos', 'amount'));
        }

    }

    public function postarMuralTurma($idTurma, Request $request)
    {
        if (Turma::find($idTurma) == null) {
            Redirect::back()->withErrors(['Turma não encontrada!']);
        } else {
            $postagem = PostagemTurma::create([
                'turma_id' => $idTurma,
                'user_id'  => Auth::user()->id,
                'conteudo' => $request->conteudo
            ]);

            if ($request->arquivo != null) {
                $originalName = mb_strtolower($request->arquivo->getClientOriginalName(), 'utf-8');

                $fileExtension = \File::extension($request->arquivo->getClientOriginalName());
                $newFileNameArquivo = md5($request->arquivo->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

                $pathArquivo = $request->arquivo->storeAs('uploads/turmas/' . $idTurma . '/arquivos', $newFileNameArquivo, 'local');

                if (!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo))) {
                    \Session::flash('error', 'Não foi possível fazer upload de seu anexo!');
                } else {
                    $postagem->update([
                        'arquivo' => $newFileNameArquivo
                    ]);
                }
            }

            return Redirect::back()->with('message', 'Postagem enviada com sucesso!');
        }
    }

    public function postExcluirPostagem($idTurma, $idPostagem)
    {
        if (PostagemTurma::find($idPostagem) != null) {
            if (\Storage::disk('local')->has('uploads/turmas/' . $idTurma . '/arquivos/' . PostagemTurma::find($idPostagem)->arquivo)) {
                \Storage::disk('local')->delete('uploads/turmas/' . $idTurma . '/arquivos/' . PostagemTurma::find($idPostagem)->arquivo);
            }

            PostagemTurma::find($idPostagem)->delete();

            return Redirect::back()->with('message', 'Postagem excluída com sucesso!');
        } else {
            return Redirect::back()->withErrors(['Postagem não encontrada!']);
        }
    }

    public function postEnviarComentarioPostagem($idTurma, $idPostagem, Request $request)
    {
        if (Turma::find($idTurma) == null) {
            Redirect::back()->withErrors(['Turma não encontrada!']);
        } else if (PostagemTurma::find($idPostagem) == null) {
            Redirect::back()->withErrors(['Postagem não encontrada!']);
        } else {
            $comentario = ComentarioPostagemTurma::create([
                'postagem_id' => $idPostagem,
                'user_id'     => Auth::user()->id,
                'conteudo'    => $request->conteudo
            ]);

            return Redirect::back()->with('message', 'Comentário enviado com sucesso!');
        }
    }

    public function postExcluirComentarioPostagem($idTurma, $idPostagem, $idComentario)
    {
        if (ComentarioPostagemTurma::find($idPostagem) == null) {
            return Redirect::back()->withErrors(['Comentário não encontrado!']);
        } else {
            ComentarioPostagemTurma::find($idPostagem)->delete();

            return Redirect::back()->with('message', 'Comentário excluído com sucesso!');
        }
    }

    public function getArquivo($idTurma, $idPostagem)
    {
        if (Turma::find($idTurma) == null) {
            Session::flash('error', 'Turma não encontrada!');

            return redirect()->route('catalogo');
        } else {
            if (PostagemTurma::find($idPostagem) == null) {
                Session::flash('error', 'Postagem não encontrada!');

                return redirect()->route('catalogo');
            } else {
                $postagem = PostagemTurma::find($idPostagem);

                if (\Storage::disk('local')->has('uploads/turmas/' . $idTurma . '/arquivos/' . $postagem->arquivo)) {
                    return \Storage::disk('local')->download('uploads/turmas/' . $idTurma . '/arquivos/' . $postagem->arquivo);
                } else {
                    Session::flash('error', 'Arquivo não encontrado!');

                    return redirect()->route('catalogo');
                }
            }
        }
    }

    public function modoPostagem($idTurma, Request $request)
    {
        if (Turma::find($idTurma) == null)
        {
            return response()->json(['error' => 'Turma não encontrada!']);
        }
        else
        {
            if ($request->postagem_aberta === "true" || $request->postagem_aberta === true)
            {
                Turma::find($idTurma)->update([
                    'postagem_aberta' => 1
                ]);
            }
            else
            {
                Turma::find($idTurma)->update([
                    'postagem_aberta' => 0
                ]);
            }

            return response()->json(['success' => 'Modo de postagem da turma modificado com sucesso!']);
        }
    }

    public function gerarConvite($idTurma, Request $request)
    {
        if (Turma::find($idTurma) == null) {
            return response()->json(['error' => 'Turma não encontrada!']);
        } else {
            $turma = Turma::find($idTurma);

            $newCodigo = md5(mb_strtolower($turma->titulo, 'utf-8') . $turma->created_at);

            $turma->update([
                'codigo_convite' => $newCodigo
            ]);

            $link = env("APP_URL") . '/gestao/turma/' . $turma->id . '/mural/convite/' . $newCodigo;

            return response()->json(['success' => 'Convite gerado com sucesso!', 'link' => $link]);
        }
    }

    public function getConvite($idTurma, $idConvite)
    {
        if (Turma::find($idTurma) == null) {
            Session::flash('error', 'Turma não encontrada!');

            return Redirect::route('catalogo');
        } else {
            $turma = Turma::find($idTurma);

            if (md5($turma->id . $turma->created_at) == $idConvite) {
                if (AlunoTurma::where([['turma_id', '=', $turma->id], ['user_id', '=', Auth::user()->id]])->first() == null) {
                    AlunoTurma::create([
                        'turma_id' => $idTurma,
                        'user_id'  => Auth::user()->id
                    ]);
                }

                Session::flash('message', 'Convite de turma aceito com sucesso!');

                return Redirect::route('turma-mural', ['idTurma' => $idTurma]);
            } else {
                Session::flash('error', 'Convite inválido!');

                return Redirect::route('catalogo');
            }
        }
    }
}
<file_sep>/app/Http/Controllers/Importacao/CursoController.php
<?php
namespace App\Http\Controllers\Importacao;

use App\Curso;
use App\Aula;
use App\ConteudoAula;
use App\Conteudo;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

use Redirect;

class CursoController extends ImportacaoController
{

    public function curso(Request $request)
    {       
        if($request->hasFile('fileImportCurso'))
        {
            if($request->file('fileImportCurso')->getClientOriginalExtension() != 'tz')
            {
                return Redirect::back()->withErrors(['Arquivo de importação inválido!']);
            }

            $userId = Auth::user()->id;
            $escolaId = Auth::user()->escola_id;
            
            $fileContent = file_get_contents($request->file('fileImportCurso')->getPathName());
            $decodeAsArray = json_decode($fileContent, true);

            $myArr = $decodeAsArray;

            /* IMPORTA CURSO */
            $arrCurso = (isset($myArr['curso'])) ? $myArr['curso'] : false;            

            if(!$arrCurso)
            {
                return Redirect::back()->withErrors(['Arquivo de importação não é do tipo curso!']);
            }

            unset($arrCurso['aulas']);

            $curso = new Curso();  
            $curso->escola_id = $escolaId;
            $curso->user_id = $userId;
            $curso->forceFill($arrCurso);
            $curso->save();         
            $insertedCursoId = $curso->id;
            /* */

            /* IMPORTA AULAS DE CURSO */
            $arrAulas = $myArr['curso']['aulas'];

            foreach($arrAulas as $index => $arrAula)
            {
                $tempAula = $arrAula;
                unset($tempAula['conteudos']);

                //ADICIONA AULA
                $aula = new Aula();  
                $aula->curso_id = $insertedCursoId;
                $aula->user_id = $userId;
                $aula->forceFill($tempAula);
                $aula->save();         
                $insertedAulaId = $aula->id;
    
                //ADICIONA CONTEUDOS DE AULA
                $arrConteudosAula = $myArr['curso']['aulas'][$index]['conteudos'];
                foreach($arrConteudosAula as $conteudoAula)
                {
                    //Adiciona Conteúdo
                    $conteudo = new Conteudo();  
                    $conteudo->user_id = $userId;
                    $conteudo->forceFill($conteudoAula);
                    $conteudo->save();         
                    $insertedConteudoId = $conteudo->id;
    
                    //Adiciona Relacionamento do Conteúdo com o Curso/Aula
                    $conteudoAula = new ConteudoAula();
                    $conteudoAula->ordem = 999;
                    $conteudoAula->conteudo_id = $insertedConteudoId;
                    $conteudoAula->curso_id = $insertedCursoId;
                    $conteudoAula->aula_id = $insertedAulaId;
                    $conteudoAula->user_id = $userId;
                    $conteudoAula->obrigatorio = 1;
                    $conteudoAula->save();
                    $insertedConteudoAulaId = $conteudo->id;
                }
                /* */    
            }
             
            return Redirect::back()->with('message', 'Curso importado com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Arquivo de importação não existe!']);
        }
    }

}<file_sep>/app/Generals/Upload/Upload.php
<?php

namespace App\Generals\Upload;

use Illuminate\Support\Facades\Storage;
use Intervention\Image\Facades\Image;

class Upload
{

    public function makeSimpleResize($image, $size, $path, $imageName)
    {
        return $this->simpleResize($image, $size, $path, $imageName);
    }




    public function makeResize($image, $size, $path)
    {
        return $this->resize($image, $size, $path);
    }




    public function makeResizeWithThumb($image, $size, $sizeThumb, $path, $pathThumb)
    {
        $fileName = md5(uniqid()) . '.' . $image->getClientOriginalExtension();
        return $this->resizeWithThumb($image, $size, $sizeThumb, $path, $pathThumb, $fileName);
    }




    private function simpleResize($image, $size, $path, $imageName)
    {
        try {
            $imageRealPath = $image->getRealPath();
            $thumbName = $imageName;
            $img = Image::make($imageRealPath);
            $img->resize(intval($size), null, function ($constraint) {
                $constraint->aspectRatio();
            });
            if (!Storage::disk('public_uploads')->exists($path)) {
                Storage::disk('public_uploads')->makeDirectory($path);
            }
            $img->save(public_path('uploads/' . $path) . '/' . $thumbName);
            return $thumbName;
        } catch (Exception $e) {
            //return $e->getMessage();
            return false;
        }
    }




    private function resize($image, $size, $path)
    {
        try {
            $imageRealPath = $image->getRealPath();
            $thumbName = md5(uniqid()) . '.' . $image->getClientOriginalExtension();
            $img = Image::make($imageRealPath);
            $img->resize(intval($size), null, function ($constraint) {
                $constraint->aspectRatio();
            });
            if (!Storage::disk('public_uploads')->exists($path)) {
                Storage::disk('public_uploads')->makeDirectory($path);
            }
            $img->save(public_path('uploads/' . $path) . '/' . $thumbName);
            return $thumbName;
        } catch (Exception $e) {
            //return $e->getMessage();
            return false;
        }
    }




    private function resizeWithThumb($image, $size, $sizeThumb, $path, $pathThumb, $fileName)
    {
        try {
            $imageRealPath = $image->getRealPath();
            $thumbName = $fileName;
            $img = Image::make($imageRealPath);
            $img->resize(intval($size), null, function ($constraint) {
                $constraint->aspectRatio();
            });
            $img->save(public_path($path) . '/' . $thumbName);

            //resize thumb
            $imgThumb = Image::make($imageRealPath);
            $imgThumb->resize(intval($sizeThumb), null, function ($constraint) {
                $constraint->aspectRatio();
            });
            $imgThumb->save(public_path($pathThumb) . '/' . $thumbName);
            return $thumbName;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }


}
<file_sep>/app/Entities/Recente/Recente.php
<?php

namespace App\Entities\Recente;

use App\Entities\Album\Album;
use Illuminate\Database\Eloquent\Model;

class Recente extends Model
{
    protected $table = "recentes";
    //Preenchiveis
    protected $fillable = [
        'user_id',
        'album_id',
        'created_at',
        'updated_at'
    ];




    public function albums()
    {
        return $this->belongsTo(Album::class, 'album_id');
    }

}
<file_sep>/app/Http/Controllers/TesteNivelamento/Aluno/TesteNivelamentoController.php
<?php

namespace App\Http\Controllers\TesteNivelamento\Aluno;

use App\Entities\Questoes\Questoes;
use App\Entities\TesteNivelamento\TesteNivelamento;
use App\Entities\TesteNivelamento\TesteNivelamentoQuestao;
use App\Entities\TesteNivelamento\TesteNivelamentoRespostaQuestao;
use App\Entities\TesteNivelamento\TesteNivelamentoResultado;
use Carbon\Carbon;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Session;

class TesteNivelamentoController extends Controller
{


    private $teste;
    private $testeQuestao;
    private $testeResultado;
    private $testeRespostaQuestao;
    private $questao;

    public function __construct(
        TesteNivelamento $teste,
        TesteNivelamentoQuestao $testeQuestao,
        TesteNivelamentoResultado $testeResultado,
        TesteNivelamentoRespostaQuestao $testeRespostaQuestao,
        Questoes $questao)
    {
        $this->teste = $teste;
        $this->testeQuestao = $testeQuestao;
        $this->testeResultado = $testeResultado;
        $this->testeRespostaQuestao = $testeRespostaQuestao;
        $this->questao = $questao;
    }


    public function index()
    {
        $testes = $this->teste->orderBy('id', 'DESC')->get();
        $finalizados = $this->testeResultado
            ->where('user_id', Auth::user()->id)
            ->where('status', 0)
            ->orWhere('status', 2)
            ->get();

        $abertos = $this->testeResultado
            ->where('user_id', Auth::user()->id)
            ->where('status', 1)
            ->get();
        return view('pages.teste.aluno.index', compact('testes', 'finalizados', 'abertos'));
    }


    public function show($idTeste)
    {
        // verifica se o status do teste esta em aberto
        $check = $this->testeResultado
            ->where('user_id', '=', Auth::user()->id)
            ->where('teste_id', '=', $idTeste)
            ->where('status', '=', 1)
            ->first();
        if ($check) {
            $teste = $this->teste->find($idTeste);

            $getQuestoesRespondidas = $this->testeRespostaQuestao
                ->where('teste_nivelamento_resultado_id', '=', $check->id)
                ->select('questao_id')
                ->get()
                ->toArray();
            $questoesRespondidas = array_pluck($getQuestoesRespondidas, 'questao_id');


            if ($teste->questoes->whereNotIn('questao_id', $questoesRespondidas)->count() <= 0) {
                return redirect()->route('teste.finalizado', $check->id);
            }

            Session::flash('msgTeste', 'Teste em aberto, finalize o teste para concluir.');
            return redirect()->route('teste.questao.exibe', [
                'idTeste'     => $teste->id,
                'idQuestao'   => $teste->questoes->whereNotIn('questao_id', $questoesRespondidas)->first()->questao_id,
                'resultadoId' => $check->id
            ]);
        }


        /*
         * grava um novo teste na tabela teste_nivelamento_resultados
         * Status
         * 0 = finalizado, todas multipla escolha
         * 1 = aberto, teste em andamento
         * 2 = aguardando correção, questão dissertativa encontrada
         */
        $resultado = $this->testeResultado->create([
            'user_id'  => Auth::user()->id,
            'teste_id' => $idTeste,
            'status'   => 1
        ]);

        $teste = $this->teste->find($idTeste);
        return redirect()->route('teste.questao.exibe', ['idTeste' => $teste->id, 'idQuestao' => $teste->questoes[0]->questao_id, 'resultadoId' => $resultado->id]);
    }

    public function getQuestao($idTeste, $idQuestao, $resultadoId)
    {
        $getQuestoesRespondidas = $this->testeRespostaQuestao
            ->where('teste_nivelamento_resultado_id', '=', $resultadoId)
            ->select('questao_id')
            ->get()
            ->toArray();
        $questoesRespondidas = array_pluck($getQuestoesRespondidas, 'questao_id');

        $teste = $this->teste->find($idTeste);
        $testeQuestao = $this->questao->find($idQuestao);
        $pesoQuestao = $this->testeQuestao
            ->where('teste_id', $idTeste)
            ->where('questao_id', $idQuestao)
            ->select('peso')
            ->first();


        $testeResultado = $this->testeResultado->find($resultadoId);
        $expired = $testeResultado->status;

        //$now = Carbon::now();
        $final_date = $testeResultado->created_at->addMinutes($teste->tempo);
        //$remainingMinutes = $now->diffInMinutes($final_date);
        //$tempoRestante = date('H:i', mktime(0, $remainingMinutes));


        if ($expired == 0 || $expired == 2) {
            Session::flash('msgExpirado', 'O tempo para responder o teste já foi expirado.');
        }

        return view('pages.teste.aluno.show', compact('teste', 'testeQuestao', 'pesoQuestao', 'resultadoId', 'expired', 'questoesRespondidas', 'final_date'));
    }


    public function cadastroQuestoes(Request $request)
    {
        // Verifica se a questão enviada é multipla escolha
        if ($request->get('alternativa')) {
            $respostaAluno = $request->get('alternativa');
            $respostaCorreta = $this->questao->find($request->get('questao_id'))->resposta_correta;


            $this->testeRespostaQuestao->create([
                'teste_nivelamento_resultado_id' => $request->get('teste_nivelamento_resultado_id'),
                'questao_id'                     => $request->get('questao_id'),
                'user_id'                        => Auth::user()->id,
                'resposta'                       => $respostaAluno,
                'correta'                        => $respostaCorreta
            ]);


            // verifica se a resposta esta correta e atualiza a soma da pontuação
            if ($respostaAluno == $respostaCorreta) {
                $resultado = $this->testeResultado->find($request->get('teste_nivelamento_resultado_id'));
                $pontuacaoAtual = $resultado->pontuacao;
                $peso = $this->testeQuestao
                    ->where('teste_id', $request->get('teste_id'))
                    ->where('questao_id', $request->get('questao_id'))
                    ->first()->peso;
                $pontuacaoFinal = $pontuacaoAtual + $peso;
                $resultado->update(['pontuacao' => $pontuacaoFinal]);
            }


        }

        // Verifica se a questão enviada é dissertativa
        if ($request->get('resposta')) {
            $this->testeRespostaQuestao->create([
                'teste_nivelamento_resultado_id' => $request->get('teste_nivelamento_resultado_id'),
                'questao_id'                     => $request->get('questao_id'),
                'user_id'                        => Auth::user()->id,
                'resposta'                       => $request->get('resposta'),
            ]);
        }


        Session::flash('msgAddQuestao', 'Cadastro realizado com successo!');


        // verifica se existe mais alguma questão relacionado ao teste para ser respondida
        $getQuestoesRespondidas = $this->testeRespostaQuestao
            ->where('teste_nivelamento_resultado_id', '=', $request->get('teste_nivelamento_resultado_id'))
            ->where('user_id', Auth::user()->id)
            ->select('questao_id')
            ->get()
            ->toArray();
        $questoesRespondidas = array_pluck($getQuestoesRespondidas, 'questao_id');
        $teste = $this->teste->find($request->get('teste_id'));

        // verifica se alguma das questões é dissertativa
        // se existir alguma dissertativa, grava o status como 2 = aguardando correção
        $checkType = $this->questao->whereIn('id', $questoesRespondidas)->where('tipo', 1)->get();
        if ($checkType->count() >= 1) {
            $status = 2;
        } else {
            $status = 0;
        }

        // Se não existir, redireciona para finalizar o teste
        if ($teste->questoes->whereNotIn('questao_id', $questoesRespondidas)->count() <= 0) {
            $this->testeResultado->find($request->get('teste_nivelamento_resultado_id'))->update(['status' => $status, 'finalizado' => Carbon::now()]);
            return redirect()->route('teste.finalizado', $request->get('teste_nivelamento_resultado_id'));
        }


        // Se existir mais alguma questão, redireciona para a próxima
        return redirect()->route('teste.questao.exibe', [
            'idTeste'     => $request->get('teste_id'),
            'idQuestao'   => $teste->questoes->whereNotIn('questao_id', $questoesRespondidas)->first()->questao_id,
            'resultadoId' => $request->get('teste_nivelamento_resultado_id')
        ]);
    }


    public function expiraUpdateAjax($id)
    {

        $getQuestoesRespondidas = $this->testeRespostaQuestao
            ->where('teste_nivelamento_resultado_id', '=', $id)
            ->where('user_id', Auth::user()->id)
            ->select('questao_id')
            ->get()
            ->toArray();
        $questoesRespondidas = array_pluck($getQuestoesRespondidas, 'questao_id');

        // verifica se alguma das questões é dissertativa
        // se existir alguma dissertativa, grava o status como 2 = aguardando correção
        $checkType = $this->questao->whereIn('id', $questoesRespondidas)->where('tipo', 1)->get();
        if ($checkType->count() >= 1) {
            $status = 2;
        } else {
            $status = 0;
        }

        $this->testeResultado->find($id)->update(['status' => $status, 'finalizado' => Carbon::now()]);
        return 'ok';
    }


    public function finalizado($id)
    {
        $resultado = $this->testeResultado->find($id);
        $questoes = $this->testeRespostaQuestao
            ->where('teste_nivelamento_resultado_id', $id)
            ->with('testeQuestao')
            ->whereHas('testeQuestao')
            ->get();

        if ($resultado->status == 2)
        {
            Session::flash('msgDissertativa', 'Aguardando correção');
        }

        return view('pages.teste.aluno.show_final', compact('resultado', 'questoes'));
    }


}
<file_sep>/app/Http/Controllers/PainelController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Illuminate\Support\Facades\Storage;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Badge;
use App\BadgeUsuario;
use App\Categoria;
use App\Conteudo;
use App\AvaliacaoInstrutor;
use App\Metrica;

use App\Curso;
use App\CursoCompleto;
use App\ConteudoCompleto;
use App\Aula;
use App\ConteudoAula;

class PainelController extends Controller
{
    public function index()
    {
        $concluidos = CursoCompleto::with('curso')->has('curso')->where([['user_id', '=', Auth::user()->id]])->get();

        $ultimos = ConteudoCompleto::with('curso')->has('curso')->where([['user_id', '=', Auth::user()->id]])->orderBy('created_at', 'desc')->get();

        $ultimos = $ultimos->unique(function ($item) {
            return $item->curso->id;
        });

        $continuar = null;

        foreach ($ultimos as $key => $ultimo)
        {
            $total_conteudos = Conteudo::whereHas('conteudo_aula', function ($query) use ($ultimo) {
                $query->where([['curso_id', '=', $ultimo->curso->id], ['obrigatorio', '=', '1']]);
            })->count();

            // if(Conteudo::where([['curso_id', '=', $ultimo->curso->id], ['obrigatorio', '=', '1']])->count() > 0)
            if($total_conteudos > 0)
            {
                $ultimo->progresso = number_format((ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $ultimo->curso->id]])->count() * 100) / $total_conteudos, 2);
            }
            else
            {
                $ultimo->progresso = 0;
            }

            if($ultimo->progresso > 100)
                $ultimo->progresso = 100;

            if($ultimo->progresso < 100 && $continuar == null)
            {
                $continuar = $ultimo;
            }
        }

        if($continuar != null)
        {
            $ultimo->qtAulas = Aula::where('curso_id', '=', $ultimo->curso->id)->count();

            foreach (Aula::where('curso_id', '=', $ultimo->curso->id)->orderBy('id', 'asc')->get() as $key => $aula)
            {
                if(ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $ultimo->curso->id], ['aula_id', '=', $aula->id]])->count() >= ConteudoAula::where([['curso_id', '=', $ultimo->curso->id], ['obrigatorio', '=', '1'], ['aula_id', '=', $aula->id]])->count())
                {
                    continue;
                }
                else
                {
                    $ultimo->ultimaAula = ($key + 1);

                    foreach (ConteudoAula::where([['curso_id', '=', $ultimo->curso->id], ['aula_id', '=', $aula->id]])->orderBy('ordem', 'asc')->get() as $key2 => $conteudo)
                    {
                        if(ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $ultimo->curso->id], ['aula_id', '=', $aula->id], ['conteudo_id', '=', $conteudo->id]])->first() != null)
                        {
                            continue;
                        }
                        else
                        {
                            $ultimo->ultimoConteudo = ($key2 + 1);
                            $ultimo->qtConteudos = ConteudoAula::where([['curso_id', '=', $ultimo->curso->id], ['aula_id', '=', $aula->id]])->orderBy('ordem', 'asc')->count();

                            break;
                        }
                    }

                    break;
                }
            }
        }

        if(count($ultimos) > 5)
        {
            $ultimos = $ultimos->splice(0, 5);
        }

        // dd($ultimos);

        return view('painel')->with(compact('continuar', 'ultimos', 'concluidos'));
    }

    public function badges()
    {
        $badges = Badge::where([['visibilidade', '=' , '1']])->get();

        foreach(BadgeUsuario::with('badge')->where('user_id', '=', Auth::user()->id)->get() as $minha)
        {
            if($badges->contains(function ($value, $key) use ($minha) { return $value->id == $minha->badge->id; }))
            {
                $badges->first(function ($value, $key) use ($minha) { return $value->id == $minha->badge->id; })->desbloqueada = true;
            }
            else
            {
                $minha = $minha->badge;

                $minha->desbloqueada = true;

                $badges->push($minha);
            }
        }

        // dd($badges);

        return view('badges')->with( compact('badges') );
    }

    public function getCertificado($idCurso)
    {
        if(Curso::find($idCurso) == null)
        {
            return response()->view('errors.404');
        }

        // if(ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $idCurso]])->count() < Conteudo::where([['curso_id', '=', $idCurso], ['obrigatorio', '=', 1]])->count())
        if(CursoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $idCurso]])->first() == null)
        {
            return response()->view('errors.404');
        }

        $curso = Curso::find($idCurso);

        $user = Auth::user();

        $dataConclusao = CursoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $idCurso]])->first()->created_at->format('d/m/Y');

        return view('painel-certificado')->with(compact('curso', 'user', 'dataConclusao'));
    }

}


<file_sep>/app/Entities/TesteNivelamento/Repository.php
<?php


namespace App\Entities\TesteNivelamento;


class Repository
{
    private $teste;
    private $testeQuestao;
    private $testeDirecionamento;
    
    public function __construct(TesteNivelamento $teste, TesteNivelamentoQuestao $testeQuestao, TesteNivelamentoDirecionamento $testeDirecionamento)
    {
        $this->teste = $teste;
        $this->testeQuestao = $testeQuestao;
        $this->testeDirecionamento = $testeDirecionamento;
    }
    
    // teste
    public function all()
    {
        return $this->teste->orderBy('id', 'DESC')->get();
    }
    
    public function find($id)
    {
        return $this->teste->find($id);
    }
    
    public function store($values)
    {
        return $this->teste->create($values);
    }
    
    public function update($id, $values)
    {
        return $this->teste->find($id)->update($values);
    }
    
    public function delete($id)
    {
        return $this->teste->find($id)->delete();
    }
    
    
    // Questão
    public function storeTesteQuestao($values)
    {
        return $this->testeQuestao->create($values);
    }
    
    public function updateTesteQuestao($id, $values)
    {
        return $this->testeQuestao->find($id)->update($values);
    }
    
    public function deleteTesteQuestao($id)
    {
        return $this->testeQuestao->find($id)->delete();
    }
    
    
    // Direcionamento
    public function storeTesteDirecionamento($values)
    {
        return $this->testeDirecionamento->create($values);
    }
    
    public function updateTesteDirecionamento($id, $values)
    {
        return $this->testeDirecionamento->find($id)->update($values);
    }
    
    public function deleteDirecionamentoQuestao($id)
    {
        return $this->testeDirecionamento->find($id)->delete();
    }
    
}
<file_sep>/app/Transacao.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class Transacao extends Model
{
    protected $table = 'transacoes';

    // protected $primaryKey = 'id'; // or null

    // public $incrementing = false;

    //Preenchiveis
    protected $fillable = [
        'referencia_id',
        'user_id',
        'sub_total',
        'adicional',
        'desconto',
        'frete',
        'total',
        'status',
        'metodo',
    ];

    // 0 = Criado
    // 1 = Pedente
    // 2 = Aguardando pagamento
    // 3 = Pagamento autorizado
    // 4 = Pagamento liberado
    // 7 = Pagamento cancelado

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'metodo' => '',
        'sub_total' => 0,
        'adicional' => 0,
        'desconto' => 0,
        'frete' => 0,
        'total' => 0,
    ];

    public function produtos()
    {
        return $this->hasMany('App\ProdutoTransacao', 'transacao_id', 'id');
    }

    public function produtos_user()
    {
        return $this->hasMany('App\ProdutoTransacao', 'transacao_id', 'id')->with('user');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/database/migrations/2019_08_08_111945_create_codigo_transmissao_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateCodigoTransmissaoTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('codigo_transmissao', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('user_id');
			$table->string('token');
			$table->integer('referencia_id');
			$table->integer('tipo');
			$table->integer('status');
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('codigo_transmissao');
	}

}
<file_sep>/app/Entities/PlanoAula/PlanoAula.php
<?php

namespace App\Entities\PlanoAula;

use App\Entities\GradeAula\GradeAula;
use Illuminate\Database\Eloquent\Model;

class PlanoAula extends Model
{
    protected $table = "plano_aulas";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'grade_aula_id',
        'assunto',
        'tarefa_classe',
        'tarefa_casa',
        'data',
        'objetivos',
        'topicos_conhecimento',
        'habilidades_competencias',
        'etapas_atividades',
        'recursos_necessarios',
        'avaliacao',
        'metodologia',
        'tema',
        'nivel_ensino',
        'ano_serie',
        'materia',
        'quantidade_aulas'
    ];

    public function grade()
    {
        return $this->belongsTo(GradeAula::class, 'grade_aula_id');
    }

    public function anexosAll()
    {
        return $this->hasMany(PlanoAulaAnexo::class, 'plano_aula_id');
    }

    public function anexosAtividades()
    {
        return $this->hasMany(PlanoAulaAnexo::class, 'plano_aula_id')->where('tipo', 1);
    }

    public function anexosMateriais()
    {
        return $this->hasMany(PlanoAulaAnexo::class, 'plano_aula_id')->where('tipo', 2);
    }

}
<file_sep>/app/Entities/Trilhas/TrilhasCurso.php
<?php

namespace App\Entities\Trilhas;

use App\Curso;
use Illuminate\Database\Eloquent\Model;

class TrilhasCurso extends Model
{
    protected $table = "trilhas_cursos";

    //Preenchiveis
    protected $fillable = [
        'trilha_id',
        'curso_id'
    ];




    public function curso()
    {
        return $this->belongsTo(Curso::class, 'curso_id');
    }




    public function trilha()
    {
        return $this->belongsTo(Trilhas::class, 'trilha_id');
    }
}
<file_sep>/app/Aplicacao.php
<?php

namespace App;

use App\Entities\Favorito\Favorito;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;
use Laracasts\Presenter\PresentableTrait;

class Aplicacao extends Model
{

    protected $table = 'aplicacoes';

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'titulo',
        'descricao',
        'status',
        'liberada',
        'destaque',
        'data_lancamento',
        'capa',
        'categoria_id',
        'nivel_ensino',
        'ano_serie',
        'tags',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'descricao'    => '',
        'status'       => 0,
        'liberada'     => 0,
        'destaque'     => 0,
        'capa'         => '',
        'categoria_id' => 1,
        'tags'         => '[]',
    ];

    // Cast fields as Carbon date
    protected $casts = [
        'tags' => 'array',
    ];

    protected $dates = [
        'data_lancamento',
    ];

    public function categoria()
    {
        return $this->belongsTo('App\Categoria', 'categoria_id');
        // return $this->hasOne('App\Categoria', 'id', 'categoria_id');
    }


    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

    public function progressos()
    {
        return $this->hasMany('App\ProgressoConteudo', 'conteudo_id')->with('user')->where('tipo', '=', 1);
    }

    public function progressos_user()
    {
        return $this->hasMany('App\ProgressoConteudo', 'conteudo_id')->with('user')->where('tipo', '=', 1);
    }

    public function favorito($idUser, $idRef)
    {
        return $this->hasOne(Favorito::class, 'referencia_id')
            ->where([['user_id', $idUser], ['referencia_id', $idRef], ['tipo', 1]])->first();
    }


}
<file_sep>/app/LiberacaoAplicacao.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class LiberacaoAplicacao extends Model
{
    protected $table = 'liberacao_aplicacao';

    //Preenchiveis
    protected $fillable = [
        'aplicacao_id',
        'user_id',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
    ];

    public function aplicacao()
    {
        return $this->belongsTo('App\Aplicacao');
    }

    public function user()
    {
        return $this->belongsTo('App\User');
    }

}
<file_sep>/app/Entities/Users/Repository.php
<?php

namespace App\Entities\Users;


use App\User;

class Repository
{
  private $user;
  
  public function __construct(User $user)
  {
    $this->user = $user;
  }
  
  
  // listar todos os usuários
  public function getAll($wherePermission = null)
  {
    if ($wherePermission !== null) {
      return $this->user->where('permissao', $wherePermission)->get();
    }
    return $this->user->all();
    
  }
  
}<file_sep>/app/Http/Controllers/ApostilaController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Conteudo;

use App\Entities\Anotacao\Anotacao;

class ApostilaController extends Controller
{
    public function index($conteudo_id)
    {
        $conteudo = Conteudo::find($conteudo_id);

        if($conteudo == null)
        {
            return redirect("404");
            // return redirect()->back()->withErrors("Conteúdo não encontrado!");
        }

        $anotacoes = Anotacao::where([['conteudo_id', '=', $conteudo_id], ['user_id', '=', Auth::user()->id]])->get();

        $marcadores = [];

        return view('play.leitor-apostila')->with( compact('conteudo', 'anotacoes', 'marcadores') );
    }

}
<file_sep>/resources/js/pages/gestao/playlists.js
window.enviarPlaylist = function () {
    $("#formNovaPlaylist #divLoading").addClass("d-none");
    $("#formNovaPlaylist #divEditar").addClass("d-none");

    $("#formNovaPlaylist #divEnviando").removeClass("d-none");
}

window.atualizarPlaylist = function () {
    $("#formEditarPlaylist #divLoading").addClass("d-none");
    $("#formEditarPlaylist #divEditar").addClass("d-none");

    $("#formEditarPlaylist #divEnviando").removeClass("d-none");
}
<file_sep>/app/Exceptions/Handler.php
<?php

namespace App\Exceptions;

use Exception;
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;

use Auth;

class Handler extends ExceptionHandler
{
    /**
     * A list of the exception types that are not reported.
     *
     * @var array
     */
    protected $dontReport = [
        //
    ];

    /**
     * A list of the inputs that are never flashed for validation exceptions.
     *
     * @var array
     */
    protected $dontFlash = [
        'password',
        'password_confirmation',
    ];

    /**
     * Report or log an exception.
     *
     * @param  \Exception  $exception
     * @return void
     */
    public function report(Exception $exception)
    {
        // Sentry actions
        // if(env("APP_ENV") != "local")
        if (app()->bound('sentry') && $this->shouldReport($exception))
        {
            $sentry = app('sentry');

            // Add user context
            if (Auth::check())
            {
                $sentry->user_context([
                    'id' => Auth::user()->id,
                    'name' => Auth::user()->name,
                    'email' => Auth::user()->email,
                    'permissao' => Auth::user()->permissao,
                    'logado' => true,
                ]);
            }
            else
            {
                $sentry->user_context([
                    'id' => null,
                    'logado' => false,
                ]);
            }

            // Add tags context
            $sentry->tags_context(['app_env' => env("APP_ENV")]);

            app('sentry')->captureException($exception);
        }

        parent::report($exception);
    }

    /**
     * Render an exception into an HTTP response.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Exception  $exception
     * @return \Illuminate\Http\Response
     */
    public function render($request, Exception $exception)
    {
        return parent::render($request, $exception);
    }
}
<file_sep>/app/Http/Controllers/RelatorioController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Illuminate\Support\Facades\Storage;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Escola;
use App\User;
use App\Turma;
use App\AlunoTurma;
use App\PostagemTurma;
use App\ComentarioPostagemTurma;
use App\DuvidaProfessor;
use App\Categoria;
use App\Curso;
use App\Aula;
use App\Aplicacao;
use App\Conteudo;
use App\ProgressoConteudo;
use App\InteracaoConteudo;
use App\AvaliacaoInstrutor;
use App\AvaliacaoConteudo;
use App\Metrica;

use App\ConteudoCompleto;
use App\AvaliacaoCurso;
use App\AvaliacaoEscola;
use App\Matricula;

class RelatorioController extends Controller
{
    public function index()
    {
        if(strtoupper(Auth::user()->permissao) == "G")
        {
            $escola = Escola::where('user_id', '=', Auth::user()->id)->first();
        }

        if(!isset($escola))
        {
            $escola = Escola::find(1);
        }
        elseif($escola == null)
        {
            $escola = Escola::find(1);
        }

        $userId = Auth::user()->id;

        $escolas = null;

        if(strtoupper(Auth::user()->permissao) == "Z")
        {
            $escolas = Escola::all();

            // Alunos
            $alunos = User::with('progressos', 'badges_user')->where([['permissao', '=', 'A']])->get();

            //Relatorios gerais
            $totalEscolas = Escola::count();

            $totalGestores = User::where('permissao', '=', 'G')->count();

            $totalProfessores = User::where('permissao', '=', 'P')->count();

            $totalTurmas = Turma::count();

            $totalAlunos = User::where('permissao', '=', 'A')->count();
        }
        else if(strtoupper(Auth::user()->permissao) == "G")
        {
            $alunos = User::with('progressos', 'badges_user')->where([['permissao', '=', 'A'], ['escola_id', '=', Auth::user()->escola_id]])->get();

            //Relatorios gerais
            $totalEscolas = Escola::count();

            $totalGestores = User::where([['permissao', '=', 'G'], ['escola_id', '=', Auth::user()->escola_id]])->count();

            $totalProfessores = User::where([['permissao', '=', 'P'], ['escola_id', '=', Auth::user()->escola_id]])->count();

            $totalTurmas = Turma::where([['escola_id', '=', Auth::user()->escola_id]])->count();

            $totalAlunos = User::where([['permissao', '=', 'A'], ['escola_id', '=', Auth::user()->escola_id]])->count();
        }
        else
        {
            $turmasId = Turma::where('user_id', '=', Auth::user()->id)->pluck('id');

            $alunos = User::with('progressos', 'badges_user')->where([['permissao', '=', 'A'], ['escola_id', '=', Auth::user()->escola_id]])
            ->whereHas('turmas_aluno', function ($query) use ($turmasId) {
                $query->whereIn('turma_id', $turmasId);
            })->get();

            //Relatorios gerais
            $totalEscolas = Escola::count();

            $totalGestores = User::where([['permissao', '=', 'G'], ['escola_id', '=', Auth::user()->escola_id]])->count();

            $totalProfessores = User::where([['permissao', '=', 'P'], ['escola_id', '=', Auth::user()->escola_id]])->count();

            $totalTurmas = Turma::where([['escola_id', '=', Auth::user()->escola_id]])->count();

            $totalAlunos = User::where([['permissao', '=', 'A'], ['escola_id', '=', Auth::user()->escola_id]])->count();
        }

        $mediaAlunosConectados = [0, 0, 0, 0, 0];

        $nivelAprendizado = [0, 0, 0, 0, 0, 0];

        foreach ($alunos as $user)
        {
            $user->acessos = Metrica::where([['titulo', '=', 'Acesso na plataforma'], ['user_id', '=', $user->id]])->count();

            if($user->acessos >= 31)
            {
                $mediaAlunosConectados[0] ++;
            }
            elseif($user->acessos >= 16 && $user->acessos <= 30)
            {
                $mediaAlunosConectados[1] ++;
            }
            elseif($user->acessos >= 6 && $user->acessos <= 15)
            {
                $mediaAlunosConectados[2] ++;
            }
            elseif($user->acessos >= 1 && $user->acessos <= 5)
            {
                $mediaAlunosConectados[3] ++;
            }
            else
            {
                $mediaAlunosConectados[4] ++;
            }

            $totalConteudosCompletos = ProgressoConteudo::where([['user_id', '=', $user->id], ['progresso', '>=', 100]])->count();
            $totalAvaliacoes = AvaliacaoConteudo::where([['user_id', '=', $user->id]])->count();
            $totalAvaliacoesPositivas = AvaliacaoConteudo::where([['user_id', '=', $user->id], ['avaliacao', '=', 1]])->count();

            if($totalConteudosCompletos == 0 || $totalAvaliacoes == 0)
            {
                $nivelAprendizado[5] ++;
            }
            else
            {
                $percentualAprendizagem = ($totalAvaliacoesPositivas * 100) / $totalAvaliacoes;

                if($percentualAprendizagem >= 80)
                {
                    $nivelAprendizado[0] ++;
                }
                elseif($percentualAprendizagem >= 60 && $percentualAprendizagem <= 79)
                {
                    $nivelAprendizado[1] ++;
                }
                elseif($percentualAprendizagem >= 40 && $percentualAprendizagem <= 59)
                {
                    $nivelAprendizado[2] ++;
                }
                elseif($percentualAprendizagem >= 20 && $percentualAprendizagem <= 39)
                {
                    $nivelAprendizado[3] ++;
                }
                else//if($percentualAprendizagem >= 0 && $percentualAprendizagem <= 19)
                {
                    $nivelAprendizado[4] ++;
                }
            }

            // foreach (ConteudoCompleto::where('user_id', '=', $user->id)->get() as $conteudo)
            // {
            //     $avaliacao = AvaliacaoConteudo::where([['user_id', '=', $user->id], ['curso_id', '=', $conteudo->curso_id], ['aula_id', '=', $conteudo->aula_id], ['conteudo_id', '=', $conteudo->id]])->get();

            //     if($avaliacao != null)
            //     {
            //         $
            //     }
            // }
        }

        // dd($nivelAprendizado);

        // Cursos

        if(strtolower(Auth::user()->permissao) == "z")
        {
            $totalCursos = Curso::count();
        }
        else
        {
            $totalCursos = Curso::where('user_id', '=', $userId)->count();
        }

        //Relatorios cursos
        if(strtolower(Auth::user()->permissao) == "z")
        {
            $cursos = Curso::with('matriculas')->get();

            $totalMatriculados = Matricula::whereHas('curso')->whereHas('user')->count();
        }
        else
        {
            $cursos = Curso::with('matriculas')->where('user_id', '=', $userId)->get();

            $totalMatriculados = Matricula::whereHas('user')->whereHas('curso', function($item) use($userId)
            {
                $item->where('user_id', '=', $userId);
            })->count();
        }

        $mediaAtividadesCompletas = 0;
        $somatoria = 0;
        $total = 0;

        $participativos = 0;

        foreach ($cursos as $curso)
        {
            foreach ($curso->matriculas as $matricula)
            {
                $matricula->user = User::find($matricula->user_id);

                $total_conteudos = Conteudo::whereHas('conteudos_aula', function ($query) use ($matricula) {
                    $query->where([['curso_id', '=', $matricula->curso_id], ['obrigatorio', '=', '1']]);
                })->count();

                if($total_conteudos > 0)
                {
                    $matricula->progresso = number_format((ConteudoCompleto::where([['user_id', '=', $matricula->user_id], ['curso_id', '=', $matricula->curso_id]])->count() * 100) / $total_conteudos, 2);
                }
                else
                {
                    $matricula->progresso = 0;
                }

                if($matricula->progresso > 0)
                    $participativos ++;

                if($matricula->progresso > 100)
                    $matricula->progresso = 100;

                $somatoria ++;
                $total += $matricula->progresso;
            }
        }

        // Conteudos

        if(strtoupper(Auth::user()->permissao) == "Z")
        {
            $totalConteudos = Conteudo::count();
        }
        elseif(strtoupper(Auth::user()->permissao) == "G")
        {
            $totalConteudos = Conteudo::where('user_id', '=', $userId)
                ->orWhereHas('user', function ($query) {
                    $query->where('escola_id', '=', Auth::user()->escola_id);
                })->count();
        }
        else
        {
            $totalConteudos = Conteudo::where('user_id', '=', $userId)->count();
        }

        //Relatorios conteudos
        if(strtoupper(Auth::user()->permissao) == "Z")
        {
            $conteudos = Conteudo::all();

            // $totalMatriculados = Matricula::count();
        }
        elseif(strtoupper(Auth::user()->permissao) == "G")
        {
            $conteudos = Conteudo::where('user_id', '=', $userId)
                ->orWhereHas('user', function ($query) {
                    $query->where('escola_id', '=', Auth::user()->escola_id);
                })->get();
        }
        else
        {
            $conteudos = Conteudo::where('user_id', '=', $userId)->get();

            // $totalMatriculados = Matricula::whereHas('curso', function($item) use($userId)
            // {
            //     $item->where('user_id', '=', $userId);
            // })->count();
        }

        $mediaAtividadesCompletas = 0;
        $somatoria = 0;
        $total = 0;

        $participativos = 0;

        if($somatoria > 0)
        {
            $mediaAtividadesCompletas = number_format($total / $somatoria, 2);

            $participacao = number_format( ($participativos * 100) / $somatoria, 2);
        }
        else
        {
            $mediaAtividadesCompletas = 0;

            $participacao = 0;
        }

        // Turmas
        if(strtoupper(Auth::user()->permissao) == "Z")
        {
            $turmas = Turma::with('alunos_user')->get();
        }
        else if(strtoupper(Auth::user()->permissao) == "G")
        {
            $turmas = Turma::with('alunos_user')->where('escola_id', '=', Auth::user()->escola_id)
                ->orWhere('user_id', '=', $userId)->get();
        }
        else
        {
            $turmas = Turma::with('alunos_user')->where('user_id', '=', $userId)->get();
        }

        foreach ($turmas as $turma)
        {
            $turma->qt_alunos = AlunoTurma::where('turma_id', '=', $turma->id)->count();

            $turma->qt_postagens = PostagemTurma::where([['turma_id', '=', $turma->id]])->count();

            $turma->qt_comentarios = 0;

            foreach(PostagemTurma::with('comentarios')->where([['turma_id', '=', $turma->id]])->get() as $postagem)
            {
                $turma->qt_comentarios += count($postagem->comentarios);
            }

            $turma->qt_duvidas = DuvidaProfessor::where([['professor_id', '=', $turma->user_id]])->count();

            $turma->alunosInativos = collect();

            $turma->alunosRisco = collect();

            $now = Carbon::now();

            $turma->qt_alunos_participativos = 0;

            foreach($turma->alunos_user as $aluno)
            {
                // dd($aluno->user);

                $aluno->qt_postagens = PostagemTurma::where([['user_id', '=', $aluno->user_id], ['turma_id', '=', $aluno->turma_id]])->count();

                $aluno->qt_comentarios = ComentarioPostagemTurma::where([['user_id', '=', $aluno->user_id]])->count();

                $aluno->qt_duvidas = DuvidaProfessor::where([['user_id', '=', $aluno->user_id], ['professor_id', '=', $turma->user_id]])->count();

                if($aluno->qt_postagens > 0 || $aluno->qt_comentarios > 0 || $aluno->qt_duvidas > 0)
                {
                    $turma->qt_alunos_participativos ++;
                }

                if($aluno->user != null ? $aluno->user->ultima_atividade != null : false)
                {
                    $diff = Carbon::parse($aluno->user->ultima_atividade)->diffInDays($now);

                    if($diff >= 30)
                    {
                        $turma->alunosInativos->push($aluno);
                    }

                    if($aluno->user->created_at == $aluno->user->ultima_atividade)
                    {
                        $turma->alunosRisco->push($aluno);
                    }
                }
            }

            $turma->participacaoAlunos = 0;

            if($turma->qt_alunos > 0)
            {
                $turma->participacaoAlunos = number_format(($turma->qt_alunos_participativos * 100) / $turma->qt_alunos, 2, ",", ".");
            }

            // dd($turma->alunosInativos);
        }

        foreach($alunos as $aluno)
        {
            $aluno->qt_acessos = Metrica::where([['titulo', '=', 'Acesso na plataforma'], ['user_id', '=', $aluno->id]])->count();

            if(AlunoTurma::where('user_id', '=', $aluno->id)->first() != null)
            {
                $aluno->qt_postagens = PostagemTurma::where([['user_id', '=', $aluno->id], ['turma_id', '=', AlunoTurma::where('user_id', '=', $aluno->id)->first()->turma_id]])->count();

                $aluno->qt_duvidas = DuvidaProfessor::where([['user_id', '=', $aluno->id], ['professor_id', '=', $turma->id]])->count();
            }
            else
            {
                $aluno->qt_postagens = 0;

                $aluno->qt_duvidas = 0;
            }

            $aluno->qt_comentarios = ComentarioPostagemTurma::where([['user_id', '=', $aluno->id]])->count();

            foreach($aluno->progressos as $progresso)
            {
                if($progresso->tipo == 1)
                {
                    if(Aplicacao::find($progresso->conteudo_id) != null)
                    {
                        $progresso->titulo = Aplicacao::find($progresso->conteudo_id)->titulo;
                    }
                    else
                    {
                        $progresso->titulo = "Aplicação " . $progresso->conteudo_id;
                    }
                }
                else if($progresso->tipo == 2)
                {
                    if(Conteudo::find($progresso->conteudo_id) != null)
                    {
                        $progresso->titulo = Conteudo::find($progresso->conteudo_id)->titulo;
                    }
                    else
                    {
                        $progresso->titulo = "Conteúdo " . $progresso->conteudo_id;
                    }
                }
            }

            $aluno->interacoes = collect();

            foreach(InteracaoConteudo::where('user_id', '=', $aluno->id)->select('conteudo_id','tipo')->get()->unique(function ($item) {
                return $item['conteudo_id'].$item['tipo'];
            }) as $interacao)
            {
                $ic = InteracaoConteudo::where([['conteudo_id', '=', $interacao->conteudo_id], ['tipo', '=', $interacao->tipo], ['user_id', '=', $aluno->id]])->first();

                if($ic == null)
                {
                    continue;
                }

                if($ic->tipo == 1)
                {
                    if(Aplicacao::find($ic->conteudo_id) != null)
                    {
                        $ic->titulo = Aplicacao::find($ic->conteudo_id)->titulo;
                    }
                    else
                    {
                        $ic->titulo = "Aplicação " . $ic->conteudo_id;
                    }
                }
                else if($ic->tipo == 2)
                {
                    if(Conteudo::find($ic->conteudo_id) != null)
                    {
                        $ic->titulo = Conteudo::find($ic->conteudo_id)->titulo;
                    }
                    else
                    {
                        $ic->titulo = "Conteúdo " . $ic->conteudo_id;
                    }
                }

                $total_interacoes = 0;

                $tempo_medio = 0;

                $tempo_total = 0;

                foreach(InteracaoConteudo::where([['conteudo_id', '=', $interacao->conteudo_id], ['tipo', '=', $interacao->tipo], ['user_id', '=', $aluno->id]])->get() as $int)
                {
                    $total_interacoes ++;

                    $tempo_total += Carbon::parse($int->inicio)->diffInSeconds(Carbon::parse($int->created_at));
                }

                if($total_interacoes > 0)
                {
                    $tempo_medio = $tempo_total / $total_interacoes;
                }

                $ultima_interacao = InteracaoConteudo::where([['conteudo_id', '=', $interacao->conteudo_id], ['tipo', '=', $interacao->tipo], ['user_id', '=', $aluno->id]])->orderBy('created_at', 'desc')->first()->created_at;

                $interacao = [ "conteudo_id" => $interacao->conteudo_id, "tipo" => $interacao->tipo, "titulo" => $ic->titulo, "tempo_medio" => $tempo_medio, "tempo_total" => $tempo_total, 'ultima_interacao' => $ultima_interacao ];

                $aluno->interacoes->push($interacao);
            }

            // dd($aluno->interacoes);

        }

        // dd($alunos);

        foreach ($turmas as $turma)
        {
            $turma->qt_alunos = AlunoTurma::where('turma_id', '=', $turma->id)->count();

            $turma->qt_postagens = PostagemTurma::where([['turma_id', '=', $turma->id]])->count();

            $turma->qt_comentarios = 0;

            foreach(PostagemTurma::with('comentarios')->where([['turma_id', '=', $turma->id]])->get() as $postagem)
            {
                $turma->qt_comentarios += count($postagem->comentarios);
            }

            $turma->qt_duvidas = DuvidaProfessor::where([['professor_id', '=', $turma->user_id]])->count();

            $turma->alunosInativos = collect();

            $turma->alunosRisco = collect();

            $now = Carbon::now();

            $turma->qt_alunos_participativos = 0;

            foreach($turma->alunos_user as $aluno)
            {
                // dd($aluno->user);

                $aluno->qt_postagens = PostagemTurma::where([['user_id', '=', $aluno->user_id], ['turma_id', '=', $aluno->turma_id]])->count();

                $aluno->qt_comentarios = ComentarioPostagemTurma::where([['user_id', '=', $aluno->user_id]])->count();

                $aluno->qt_duvidas = DuvidaProfessor::where([['user_id', '=', $aluno->user_id], ['professor_id', '=', $turma->user_id]])->count();

                if($aluno->qt_postagens > 0 || $aluno->qt_comentarios > 0 || $aluno->qt_duvidas > 0)
                {
                    $turma->qt_alunos_participativos ++;
                }

                if($aluno->user != null ? $aluno->user->ultima_atividade != null : false)
                {
                    $diff = Carbon::parse($aluno->user->ultima_atividade)->diffInDays($now);

                    if($diff >= 30)
                    {
                        $turma->alunosInativos->push($aluno);
                    }

                    if($aluno->user->created_at == $aluno->user->ultima_atividade)
                    {
                        $turma->alunosRisco->push($aluno);
                    }
                }
            }

            $turma->participacaoAlunos = 0;

            if($turma->qt_alunos > 0)
            {
                $turma->participacaoAlunos = number_format(($turma->qt_alunos_participativos * 100) / $turma->qt_alunos, 2, ",", ".");
            }

            // dd($turma->alunosInativos);
        }

        // $metricas = Metrica::all();

        // dd($metricas->groupBy('titulo'));

        $metricas = Metrica::query();

        $metricas->when( Auth::user()->permissao != "Z", function ($q) use ($escola) {
            return $q->whereHas('user', function ($q2) use ($escola) {
                $q2->where('escola_id', $escola->id);
            });
        });

        $metricas = $metricas->pluck('titulo')->unique();

        // dd($metricas);

        $metricaAcessosPlataforma = Metrica::where([['titulo', 'Acesso na plataforma']])
        ->whereHas('user', function ($query) use ($escola) {
            $query->where('escola_id', $escola->id);
        })
        ->orderBy('created_at', 'asc')->get(['user_id', 'created_at'])->groupBy(function($val) {
                return Carbon::parse($val->created_at)->format('d/m/Y');
        });

        foreach ($metricaAcessosPlataforma as $key => $metrica)
        {
            $metricaAcessosPlataforma[$key] = count($metrica);
        }

        if(AvaliacaoInstrutor::where('instrutor_id', '=', Auth::user()->id)->avg('avaliacao') > 0)
        {
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', Auth::user()->id)->avg('avaliacao');
        }
        else
        {
            $avaliacaoInstrutor = '-';
        }

        $avaliacoes = AvaliacaoInstrutor::with('user')->where('instrutor_id', '=', Auth::user()->id)->orderBy('created_at', 'desc')->get();

        return view('gestao.relatorios')->with(compact('escolas', 'escola', 'turmas', 'alunos', 'cursos',
        'totalEscolas', 'totalGestores', 'totalProfessores', 'totalTurmas', 'totalAlunos',
        'mediaAtividadesCompletas', 'participacao', 'mediaAlunosConectados', 'nivelAprendizado', 'conteudos',
        'totalMatriculados', 'cursos', 'avaliacoes', 'avaliacaoInstrutor',
        'metricas', 'metricaAcessosPlataforma'));
    }

    public function avaliacoesProfessor($idProfessor)
    {
        $professor = User::with('escola', 'turmas_instrutor')->find($idProfessor);

        foreach ($professor->turmas_instrutor as $turma)
        {
            $turma->qt_alunos = AlunoTurma::where('turma_id', '=', $turma->id)->count();
        }

        if($professor == null)
        {
            return redirect()->back()->withErrors("Professor não encontrado!");
        }
        else if(strtoupper($professor->permissao) != "P" && strtoupper($professor->permissao) != "G" && strtoupper($professor->permissao) != "Z")
        {
            return redirect()->back()->withErrors("Professor não encontrado!");
        }

        //Relatorios avaliacoes instrutor

        if(AvaliacaoInstrutor::where('instrutor_id', '=', $idProfessor)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $idProfessor)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $avaliacoes = AvaliacaoInstrutor::with('user')->where('instrutor_id', '=', $idProfessor)->orderBy('created_at', 'desc')->get();

        return view('professor.avaliacoes')->with(compact('professor', 'avaliacoes', 'avaliacaoInstrutor'));
    }
}


<file_sep>/app/ArtigoAjuda.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class ArtigoAjuda extends Model
{
    protected $table = 'artigo_ajuda';

    //Preenchiveis
    protected $fillable = [
        'id',
        'user_id',
        'titulo',
        'conteudo',
        'categoria',
        'marcadores',
        'status',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'categoria' => '',
        'marcadores' => '',
        'status' => 0,
    ];

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

    public function avaliacoes()
    {
        return $this->belongsTo('App\AvaliacaoArtigoAjuda');
    }

    public function avaliacoes_user()
    {
        return $this->belongsTo('App\AvaliacaoArtigoAjuda', 'id', 'artigo_ajuda_id')->where(function($query) {

            if(\Auth::check())
            {
                $query->where('user_id', '=', \Auth::user()->id);
            }
            else
            {
                $query->whereNull('id');
            }

        });
    }

}
<file_sep>/app/Http/Controllers/Exportacao/AulaController.php
<?php
namespace App\Http\Controllers\Exportacao;

use App\Aula;
use App\ConteudoAula;
use App\Conteudo;

class AulaController extends ExportacaoController
{

    public function aula($idCurso, $idAula)
    {       
        $aula = Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first();
        $aula->makeHidden(['id', 'curso_id', 'user_id', 'created_at', 'updated_at']); //LISTA DE CAMPOS QUE NÃO PRECISAMOS CAPTURAR.

        $aulaConteudos = ConteudoAula::where([['aula_id', '=', $idAula], ['curso_id', '=', $idCurso]])->get();
        foreach($aulaConteudos as $aulaConteudo)
        {
            $aulaConteudo = Conteudo::find($aulaConteudo->conteudo_id);
            $aulaConteudo->makeHidden(['id', 'user_id', 'created_at', 'updated_at']); //LISTA DE CAMPOS QUE NÃO PRECISAMOS CAPTURAR.

            $resAulaConteudos[] = $aulaConteudo;            
        }

        $res['aula'] = $aula;
        $res['aula']['conteudos'] = $resAulaConteudos;

        $res = json_encode($res);

        $fileName = $this->generateFileName('aula', $aula->titulo, 'tz');

        return $this->callDownloadFromStream($res, $fileName, '');
    }

}<file_sep>/resources/js/pages/gestao/audios-interacoes/admin/viewAudioInteracoes.js
window.excluirAudioInteracao = function (id) {
    if ($("#formExcluirAudioInteracao" + id).length == 0)
        return;

    swal({
        title: 'Excluir interação?',
        text: "Você deseja mesmo excluir esta interação? Todo seu conteúdo será apagado!",
        icon: "warning",
        buttons: ['Não', 'Sim, excluir!'],
        dangerMode: true,
    }).then((result) => {
        if (result == true) {
            $("#formExcluirAudioInteracao" + id).submit();
        }
    });
}    

/*
function readableDuration(seconds) {
    sec = Math.floor( seconds );    
    min = Math.floor( sec / 60 );
    min = min >= 10 ? min : '0' + min;    
    sec = Math.floor( sec % 60 );
    sec = sec >= 10 ? sec : '0' + sec;    

    return min + ':' + sec;
}
*/

function formatTime(seconds) {
    return [
        parseInt(seconds / 60 / 60),
        parseInt(seconds / 60 % 60),
        parseInt(seconds % 60)
    ]
        .join(":")
        .replace(/\b(\d)\b/g, "0$1")
}   

function hmsToSecondsOnly(str) {
    var p = str.split(':'),
        s = 0, m = 1;

    while (p.length > 0) {
        s += m * parseInt(p.pop(), 10);
        m *= 60;
    }

    return s;
}  

if($('.container-seekbar').length) {
    var audioplayer = document.createElement("audio");
    audioplayer.src = document.getElementById('audio_url').value;

    audioplayer.onloadedmetadata = function () {
        $('.end-timer-view').text(formatTime(audioplayer.duration));
    }
}

/* SEEKBAR COMPONENT */ 
function createSeekBarComponent(id) { 
    var seekbar = document.createElement('input');
        seekbar.id = id + "_seekbar";
        seekbar.type = 'range';
        seekbar.value = '';
        seekbar.step = 'any';

    $('#'+id).find('.container-seekbar').html(seekbar);

    var audioplayer = document.createElement("audio");
    audioplayer.src = document.getElementById('audio_url').value;

    if($('#'+id).find('.txtTempoAudioInteracao').val()) {
        seekbar.value = hmsToSecondsOnly($('#'+id).find('.txtTempoAudioInteracao').val());      
    }

    audioplayer.addEventListener("canplaythrough", function () {
        //alert('The file is loaded and ready to play!');
    }, false);

    audioplayer.onloadedmetadata = function () {
        seekbar.setAttribute('max', audioplayer.duration);
        $('#' + id).find('.end-timer').text(formatTime(audioplayer.duration));
    }

    seekbar.onchange = function() {
        audioplayer.currentTime = seekbar.value;
    }

    seekbar.oninput = function() {
        audioplayer.currentTime = seekbar.value;
        $('#' + id).find('.txtTempoAudioInteracao').val(formatTime(audioplayer.currentTime));
    }

    audioplayer.ontimeupdate = function() {
        seekbar.value = audioplayer.currentTime;      
    }
}

window.novaInteracaoAudio = function(id) {
    createSeekBarComponent(id);
};

window.editarInteracaoAudio = function(id) {
    createSeekBarComponent(id);
}
/* */<file_sep>/app/Console/Commands/EmailExampleCron.php
<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;

class EmailExampleCron extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'email.example:cron';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Command description';

    /**
     * Create a new command instance.
     *
     * @return void
     */
    public function __construct()
    {
        parent::__construct();
    }

    /**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        //Do your actions here

        \Mail::send([], [], function($message) {


            $message
            ->from('<EMAIL>', '<NAME>')
            ->to('<EMAIL>')
            ->subject('Automatic Testing mails - ' . date("H:i d/m/Y"))
            // ->setBody('<h1>Hi, welcome user!</h1>', 'text/html'); // for HTML rich messages
            ->setBody('Apenas um e-mail de teste que deve ser enviado de tempos em tempos automáticamente!'); // assuming text/plain

        });

        $this->info('E-mail Example Cron comando rodando com êxito');
    }
}
<file_sep>/app/Http/Controllers/Album/Api/AlbumApiController.php
<?php

namespace App\Http\Controllers\Album\Api;

use App\Entities\Album\Album;
use Illuminate\Support\Facades\DB;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class AlbumApiController extends Controller
{

    public function destaques($idEscola = '')
    {
        try
        {
            if(isset($idEscola) && !empty($idEscola))
            {
                $albums = Album::select(
                'albums.id',
                'albums.titulo',
                'albums.capa as url',
                'albums.descricao',
                'albums.categoria',
                'albums.user_id as artist',
                'albums.user_id')
                ->join('users', 'albums.user_id', '=', 'users.id')
                ->join('escolas', 'users.escola_id', '=', DB::raw($idEscola))
                ->with(['audios' => function ($query)
                {
                    $query->select(
                    'audios.id',
                    'audios.titulo as title',
                    'audios.user_id as artist',
                    'audios.file as url',
                    'audios.descricao',
                    'audios.duracao as duration');
                }])
                ->distinct()
                ->orderBy('albums.id', 'DESC')
                ->limit(5)
                ->get();
            }
            else
            {
                $albums = Album::select(
                'albums.id',
                'albums.titulo',
                'albums.capa as url',
                'albums.descricao',
                'albums.categoria',
                'albums.user_id as artist',
                'albums.user_id')
                ->with(['audios' => function ($query)
                {
                    $query->select(
                    'audios.id',
                    'audios.titulo as title',
                    'audios.user_id as artist',
                    'audios.file as url',
                    'audios.descricao',
                    'audios.duracao as duration');
                }])
                ->distinct()
                ->orderBy('albums.id', 'DESC')
                ->limit(5)
                ->get();
            }

            if (!$albums)
            {
                return response()->json(['error' => 'Nenhum álbum foi encontrado']);
            }

            return response()->json($albums);
        }
        catch (\Exception $exception)
        {
            return response()->json(["error" => "Erro ao listar.", "message:" => $exception->getMessage()]);
        }
    }




    public function listar($idEscola, $filter = null)
    {

        if($filter == null)
        {
            $filter = $idEscola;

            $idEscola = null;
        }

        try
        {
            if ($filter !== null)
            {
                if(isset($idEscola))
                {
                    $albums = Album::select(
                    'albums.id',
                    'albums.titulo',
                    'albums.capa as url',
                    'albums.descricao',
                    'albums.categoria',
                    'albums.user_id as artist',
                    'albums.user_id')
                    ->join('users', 'albums.user_id', '=', 'users.id')
                    ->join('escolas', 'users.escola_id', '=', DB::raw($idEscola))
                    ->where('categoria', $filter)
                    ->orWhereHas('categoria', function ($q) use ($filter)
                    {
                        $q->where('titulo', '=', $filter);
                    })
                    ->with(['audios' => function ($query)
                    {
                        $query->select(
                        'audios.id',
                        'audios.titulo as title',
                        'audios.user_id as artist',
                        'audios.file as url',
                        'audios.descricao',
                        'audios.duracao as duration');
                    }])
                    ->distinct()
                    ->orderBy('albums.id', 'DESC')
                    ->paginate(10);
                }
                else
                {
                    $albums = Album::select(
                    'albums.id',
                    'albums.titulo',
                    'albums.capa as url',
                    'albums.descricao',
                    'albums.categoria',
                    'albums.user_id as artist',
                    'albums.user_id')
                    ->where('categoria', $filter)
                    ->orWhereHas('categoria', function ($q) use ($filter)
                    {
                        $q->where('titulo', '=', $filter);
                    })
                    ->with(['audios' => function ($query)
                    {
                        $query->select(
                        'audios.id',
                        'audios.titulo as title',
                        'audios.user_id as artist',
                        'audios.file as url',
                        'audios.descricao',
                        'audios.duracao as duration');
                    }])
                    ->distinct()
                    ->orderBy('albums.id', 'DESC')
                    ->paginate(10);
                }

                return response()->json($albums);
            }

            if(isset($idEscola))
            {
                $albums = Album::select(
                'albums.id',
                'albums.titulo',
                'albums.capa as url',
                'albums.descricao',
                'albums.categoria',
                'albums.user_id as artist',
                'albums.user_id')
                ->join('users', 'albums.user_id', '=', 'users.id')
                ->join('escolas', 'users.escola_id', '=', DB::raw($idEscola))
                ->with(['audios' => function ($query)
                {
                    $query->select(
                    'audios.id',
                    'audios.titulo as title',
                    'audios.user_id as artist',
                    'audios.file as url',
                    'audios.descricao',
                    'audios.duracao as duration'
                    );
                }])
                ->distinct()
                ->orderBy('id', 'DESC')
                ->paginate(10);
            }
            else
            {
                $albums = Album::select(
                'albums.id',
                'albums.titulo',
                'albums.capa as url',
                'albums.descricao',
                'albums.categoria',
                'albums.user_id as artist',
                'albums.user_id')
                ->with(['audios' => function ($query)
                {
                    $query->select(
                    'audios.id',
                    'audios.titulo as title',
                    'audios.user_id as artist',
                    'audios.file as url',
                    'audios.descricao',
                    'audios.duracao as duration'
                    );
                }])
                ->distinct()
                ->orderBy('id', 'DESC')
                ->paginate(10);
            }

            if ($albums->isEmpty())
            {
                return response()->json(['error' => 'Nenhum álbum foi encontrado']);
            }

            return response()->json($albums);
        }
        catch (\Exception $exception)
        {
            return response()->json(["error" => "Erro ao listar.", "message:" => $exception->getMessage()]);
        }
    }




    public function show($idAlbum)
    {
        try {
            $album = Album::with(['audios' => function ($query) {
                $query->select(
                'audios.id',
                'audios.titulo as title',
                'audios.user_id as artist',
                'audios.file as url',
                'audios.descricao',
                'audios.duracao as duration');
            }])
            ->select(
            'albums.id',
            'albums.titulo',
            'albums.capa as url',
            'albums.descricao',
            'albums.categoria',
            'albums.user_id as artist',
            'albums.user_id')
            ->find($idAlbum);

            if (!$album)
            {
                return response()->json(['error' => 'Nenhum álbum foi encontrado']);
            }

            return response()->json($album);
        }
        catch (\Exception $exception)
        {
            return response()->json(["error" => "Erro ao encontrar", "message:" => $exception->getMessage()]);
        }
    }
}

<file_sep>/app/Entities/Badges/Repository.php
<?php

namespace App\Entities\Badges;


use App\Badge;

class Repository
{
  private $badge;
  
  public function __construct(Badge $badge)
  {
    $this->badge = $badge;
  }
  
  // listar todas as badges
  public function all()
  {
    return $this->badge->all();
  }
  
  
  //deletar uma badge
  public function delete($id)
  {
    return $this->badge->find($id)->delete();
  }
  
  // cadastrar novas badges
  public function store($values)
  {
    $this->badge->create($values);
  }
  
  
  // atualiza uma badge
  public function update($id, $values)
  {
    return $this->badge->find($id)->update($values);
  }
  
  // Retorna uma badge
  public function find($idBadge)
  {
    return $this->badge->find($idBadge);
  }
  
}<file_sep>/app/Http/Controllers/Estatisticas/Alunos/EstatisticasController.php
<?php

namespace App\Http\Controllers\Estatisticas\Alunos;

use App\Entities\HabilidadeUsuario\HabilidadeUsuario;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

use Carbon\Carbon;

use App\Entities\GradeAula\GradeAula;

use App\AlunoTurma;
use App\Entities\GamificacaoUsuario\GamificacaoUsuario;
use App\Escola;
use App\Turma;
use App\User;

class EstatisticasController extends Controller
{
    public function index()
    {
        // dd("Home");

        // \App\Services\GamificacaoService::loginIncrement();
        // \App\Services\GamificacaoService::incrementUserXP(1);

        $habilidades = HabilidadeUsuario::where('user_id', Auth::user()->id)->count();

        $aulas = $this->getAulas(date("Y-m-d"), "todas");

        // dd($aulas);

        $usersXps = User::with('gamificacao')
        // where([['permissao', '=', 'A']])
        ->get()
        ->sortByDesc('gamificacao.xp')->values();

        // $usersXps = GamificacaoUsuario::select('user_id', 'xp')
        //     ->orderBy('xp', 'DESC')
        //     ->limit(20)
        //     ->get();

        $escolas = Escola::all();

        foreach ($escolas as $key => $escola)
        {
            $total = 0;

            foreach ($escola->alunos as $key => $aluno)
            {
                if($aluno->gamificacao != null)
                {
                    $total += $aluno->gamificacao->sum('xp');
                }
            }

            $escola->xp = $total;
        }

        $escolas = $escolas->sortByDesc('xp')->values();

        $turmas = Turma::with('alunos.user.gamificacao')->whereHas('alunos.user')->get();

        foreach ($turmas as $key => $turma)
        {
            $total = 0;
            foreach ($turma->alunos as $key => $aluno)
            {
                if($aluno->user->gamificacao != null)
                {
                    $total += $aluno->user->gamificacao->sum('xp');
                }
                // $total += 1;
            }

            $turma->xp = $total;
        }

        $turmas = $turmas->sortByDesc('xp')->values();


        $userIndexGet = $usersXps->search(function ($user) {
            return $user->id === Auth::id();
        });

        ($userIndexGet !== false ? $userIndex = $userIndexGet + 1 : $userIndex = $userIndexGet);
        // $userIndex = $userIndexGet;

        $escolaUserIndexGet = $escolas->search(function ($escola) {
            return $escola->id === Auth::user()->escola_id;
        });

        ($escolaUserIndexGet !== false ? $escolaIndex = $escolaUserIndexGet + 1 : $escolaIndex = $escolaUserIndexGet);

        $turmaIndex = null;

        if(AlunoTurma::where('user_id', Auth::user()->id)->exists())
        {
            $turmaIndexGet = $turmas->search(function ($turma) {
                $turmaId = AlunoTurma::where('user_id', Auth::user()->id)->first();
                return $turma->id === $turmaId->turma_id;
            });

            ($turmaIndexGet !== false ? $turmaIndex = $turmaIndexGet + 1 : $turmaIndex = $turmaIndexGet);
        }

        // $userLogged = GamificacaoUsuario::where('user_id', Auth::id())->first();
        $userLogged = Auth::user()->with('gamificacao');

        if(AlunoTurma::where('user_id', Auth::user()->id)->exists())
        {
            $idUserTurma = AlunoTurma::where('user_id', Auth::user()->id)->first()->turma_id;
        }

        return view('pages.estatisticas.alunos.index', compact('aulas', 'habilidades', 'userIndex', 'userLogged', 'turmaIndex'));
    }

    private function getAulas($date, $turma)
    {
        $dayOfWeek = Carbon::createFromFormat('Y-m-d', $date)->dayOfWeek;
        if ($turma === "todas")
        {
            $turmasId = [];
            foreach (Auth::user()->turmas_aluno as $turma) {
                $turmasId[] = $turma->turma_id;
            }

            // Retorna as grades de aula relacionadas a todas as turmas que o aluno faz parte.
            return GradeAula::whereIn('turma_id', $turmasId)
                ->where(function ($query) use ($dayOfWeek, $date) {
                    $query->where([['recorrente', 0], ['data', $date]]);
                    $query->orWhere([['recorrente', 1], ['dia', $dayOfWeek]]);
                })->with('planos')->orderBy('hora_inicial')->get();
        }

        // Retorna as grades de aula relacionada a uma turma.
        return GradeAula::where('turma_id', $turma)->where(function ($query) use ($dayOfWeek, $date) {
            $query->where([['recorrente', 0], ['data', $date]]);
            $query->orWhere([['recorrente', 1], ['dia', $dayOfWeek]]);
        })->get();
    }
}
<file_sep>/app/Entities/PlanoAula/PlanoAulaAnexo.php
<?php

namespace App\Entities\PlanoAula;

use App\Conteudo;
use App\Generals\Presenter\PlanoAula\PlanoAulaAnexoPresenter;
use Illuminate\Database\Eloquent\Model;
use Laracasts\Presenter\PresentableTrait;

class PlanoAulaAnexo extends Model
{
    use PresentableTrait;
    protected $presenter = PlanoAulaAnexoPresenter::class;

    protected $table = "plano_aula_anexos";

    //Preenchiveis
    protected $fillable = [
        'tipo', // 1 atividades - 2 materiais
        'plano_aula_id',
        'conteudo_id',
    ];

    public function conteudo()
    {
        return $this->belongsTo(Conteudo::class, 'conteudo_id');
    }

}
<file_sep>/app/Http/Controllers/Exportacao/CursoController.php
<?php
namespace App\Http\Controllers\Exportacao;

use App\Curso;
use App\Aula;
use App\ConteudoAula;
use App\Conteudo;

class CursoController extends ExportacaoController
{

    public function curso($idCurso)
    {
        $curso = Curso::find($idCurso);
        $curso->makeHidden(['id', 'user_id', 'created_at', 'updated_at']); //LISTA DE CAMPOS QUE NÃO PRECISAMOS CAPTURAR.

        $aulas = Aula::where('curso_id', $idCurso)->get();
        $aulas->makeHidden(['id', 'curso_id', 'user_id', 'created_at', 'updated_at']); //LISTA DE CAMPOS QUE NÃO PRECISAMOS CAPTURAR.

        foreach($aulas as $index => $aula)
        {
            $aulaConteudos = ConteudoAula::where([['aula_id', '=', $aula->id], ['curso_id', '=', $idCurso]])->get();
            $aulaConteudos->makeHidden(['id', 'user_id', 'created_at', 'updated_at']); //LISTA DE CAMPOS QUE NÃO PRECISAMOS CAPTURAR.
            
            foreach($aulaConteudos as $aulaConteudo)
            {
                $aulaConteudo = Conteudo::find($aulaConteudo->conteudo_id);
                $aulaConteudo->makeHidden(['id', 'user_id', 'created_at', 'updated_at']); //LISTA DE CAMPOS QUE NÃO PRECISAMOS CAPTURAR.
    
                $resAulaConteudos[] = $aulaConteudo;
            }  

            $resAulas[$index] = $aula; 
            $resAulas[$index]['conteudos'] = $resAulaConteudos;
        }
        
        $res['curso'] = $curso;
        $res['curso']['aulas'] = $resAulas;

        $res = json_encode($res);

        $fileName = $this->generateFileName('curso', $curso->titulo, 'tz');

        return $this->callDownloadFromStream($res, $fileName, '');
    }

}<file_sep>/app/Entities/TesteNivelamento/TesteNivelamentoResultado.php
<?php

namespace App\Entities\TesteNivelamento;

use App\User;
use Illuminate\Database\Eloquent\Model;

class TesteNivelamentoResultado extends Model
{
    protected $table = "teste_nivelamento_resultados";
    
    //Preenchiveis
    protected $fillable = [
        'user_id',
        'teste_id',
        'pontuacao',
        'finalizado',
        'status',
    ];
    
    
    public function teste()
    {
        return $this->belongsTo(TesteNivelamento::class, 'teste_id');
    }
    
    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }
    
    
}
<file_sep>/app/Http/Controllers/TesteNivelamento/Admin/TesteNivelamentoController.php
<?php

namespace App\Http\Controllers\TesteNivelamento\Admin;

use App\Entities\Questoes\Questoes;
use App\Entities\TesteNivelamento\TesteNivelamento;
use App\Entities\TesteNivelamento\TesteNivelamentoDirecionamento;
use App\Entities\TesteNivelamento\TesteNivelamentoQuestao;
use App\Entities\TesteNivelamento\TesteNivelamentoRespostaQuestao;
use App\Entities\TesteNivelamento\TesteNivelamentoResultado;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class TesteNivelamentoController extends Controller
{
    private $teste;
    private $testeQuestao;
    private $testeDirecionamento;
    private $questao;
    private $resultado;
    
    public function __construct(
        TesteNivelamento $teste,
        TesteNivelamentoQuestao $testeQuestao,
        TesteNivelamentoDirecionamento $testeDirecionamento,
        TesteNivelamentoRespostaQuestao $testeRespostaQuestao,
        Questoes $questao,
        TesteNivelamentoResultado $resultado)
    {
        $this->teste = $teste;
        $this->testeQuestao = $testeQuestao;
        $this->testeDirecionamento = $testeDirecionamento;
        $this->testeRespostaQuestao = $testeRespostaQuestao;
        $this->questao = $questao;
        $this->resultado = $resultado;
    }
    
    public function index()
    {
        $testes = $this->teste->orderBy('id', 'DESC')->get();
        return view('pages.teste.admin.index', compact('testes'));
    }
    
    public function store(Request $request)
    {
        $this->validate($request, [
            'titulo' => 'required',
            'peso'   => 'required'
        ], [
            'peso.required' => 'Adicione pelo menos uma questão ao seu teste!'
        ]);
        
        // Grava o teste no banco e retorna o ID
        $testeId = $this->teste->create([
            'user_id'   => Auth::user()->id,
            'titulo'    => $request->get('titulo'),
            'descricao' => $request->get('descricao'),
            'tempo'     => $request->get('tempo')
        ])->id;
        
        
        // Grava as questões relacionadas ao teste
        foreach ($request->get('peso') as $key => $peso) {
            $this->testeQuestao->create(['teste_id' => $testeId, 'questao_id' => $key, 'peso' => $peso]);
        }
        
        // Verifica se existe um redirecionamento no request
        // Se existir grava os redirecionamentos relacionados ao teste
        if ($request->get('regra') !== null) {
            $direcionamentos = array_map(null, $request->get('regra'), $request->get('pontuacao'), $request->get('direcionamento'));
            foreach ($direcionamentos as $direc) {
                $this->testeDirecionamento->create([
                    'teste_id'       => $testeId,
                    'regra'          => $direc[0],
                    'pontuacao'      => $direc[1],
                    'direcionamento' => $direc[2]
                ]);
            }
        }
        
        return redirect()->route('gestao.teste.listar')->with('message', 'Cadastro realizado com sucesso!');
    }
    
    
    public function edit($idTeste)
    {
        $teste = $this->teste->find($idTeste);
        $questoes = $this->questao->select('titulo', 'id')->get();
        return view('pages.teste.admin.edit', compact('teste', 'questoes'));
    }
    
    
    public function update($idTeste, Request $request)
    {
        //dd($request->all());
        $this->validate($request, ['titulo' => 'required']);
        
        // atualiza o teste
        $this->teste->find($idTeste)->update([
            'titulo'    => $request->get('titulo'),
            'descricao' => $request->get('descricao'),
            'tempo'     => $request->get('tempo')
        ]);
        
        // atualiza o peso das questões
        if ($request->get('peso')) {
            foreach ($request->get('peso') as $key => $peso) {
                $this->testeQuestao->find($key)->update(['peso' => $peso]);
            }
        }
        
        // verifica se existe novas questões adicionadas
        // Adiciona questão
        if ($request->get('peso_new')) {
            foreach ($request->get('peso_new') as $key => $peso) {
                $this->testeQuestao->create([
                    'teste_id'   => $idTeste,
                    'questao_id' => $key,
                    'peso'       => $peso
                ]);
            }
        }
        
        
        // verifica se existe questões para ser excluidas
        // remove questões
        if ($request->get('questoesExcluidas')) {
            foreach ($request->get('questoesExcluidas') as $questao) {
                $this->testeQuestao->find($questao)->delete();
            }
        }
        
        
        // Atualiza os dados dos direcionamentos
        if ($request->get('regra') !== null) {
            $keys = array_keys($request->get('regra'));
            $direcionamentos = array_map(null, $keys, $request->get('regra'), $request->get('pontuacao'), $request->get('direcionamento'));
            foreach ($direcionamentos as $direc) {
                $this->testeDirecionamento->find($direc[0])->update([
                    'regra'          => $direc[1],
                    'pontuacao'      => $direc[2],
                    'direcionamento' => $direc[3]
                ]);
            }
        }
        
        // verifica se existe direcionamentos para ser excluidos
        // remove direcionamentos
        if ($request->get('direcExcluidos')) {
            foreach ($request->get('direcExcluidos') as $dirExc) {
                $this->testeDirecionamento->find($dirExc)->delete();
            }
        }
        
        // Verifica se existe um novo redirecionamento no request
        // Se existir grava os redirecionamentos relacionados ao teste
        if ($request->get('regra_new') !== null) {
            $direcionamentos = array_map(null, $request->get('regra_new'), $request->get('pontuacao_new'), $request->get('direcionamento_new'));
            foreach ($direcionamentos as $direc) {
                $this->testeDirecionamento->create([
                    'teste_id'       => $idTeste,
                    'regra'          => $direc[0],
                    'pontuacao'      => $direc[1],
                    'direcionamento' => $direc[2]
                ]);
            }
        }
        
        //return redirect()->route('gestao.teste.listar')->with('message', 'Teste atualizado com sucesso!');
        return redirect()->back()->with('message', 'Teste atualizado com sucesso!');
    }
    
    
    public function delete(Request $request)
    {
        $this->teste->find($request->idTeste)->delete;
        return redirect()->route('gestao.teste.listar')->with('message', 'Teste excluído com sucesso!');
    }
    
    
    public function listarResultados($idTeste)
    {
        $teste = $this->teste->find($idTeste);
        $finalizados = $this->resultado
            ->where('teste_id', $idTeste)
            ->where('status', 0)// apenas testes finalizados
            ->latest()
            ->get();
        
        $correcoes = $this->resultado
            ->where('teste_id', $idTeste)
            ->where('status', 2)// apenas testes aguardando correção
            ->latest()
            ->get();
        return view('pages.teste.admin.resultados', compact('finalizados', 'correcoes', 'teste'));
    }
    
    
    public function corrigeResultado($idResultado)
    {
        $resultado = $this->resultado->find($idResultado);
        $questoes = $this->testeRespostaQuestao
            ->where('teste_nivelamento_resultado_id', $idResultado)
            ->with('testeQuestao')
            ->get();
    
        $countRespostas = $this->testeRespostaQuestao
            ->where('teste_nivelamento_resultado_id', $resultado->id)
            ->where('correta', null)
            ->get()
            ->count();
        
        return view('pages.teste.admin.resultados_corrige', compact('resultado', 'questoes', 'countRespostas'));
    }
    
    public function correcaoResultado($idRespostaQuestao, $value)
    {
        $respostaQuestao = $this->testeRespostaQuestao->find($idRespostaQuestao);
        $resultado = $this->resultado->find($respostaQuestao->teste_nivelamento_resultado_id);
        
        if ($value == 'true') {
            $pontuacaoFinal = $resultado->pontuacao + $respostaQuestao->testeQuestao->peso;
            $resultado->update(['pontuacao' => $pontuacaoFinal]);
        }
        
        $respostaQuestao->update(['correta' => $value]);
        
        // verifica se existe mais alguma questão para ser corrigida
        $checkRespostas = $this->testeRespostaQuestao
            ->where('teste_nivelamento_resultado_id', $resultado->id)
            ->where('correta', null)
            ->get()
            ->count();
        
        //se não existir mais nenhuma questão, atualiza o teste como finalizado, status = 0
        if ($checkRespostas <= 0) {
            $resultado->update(['status' => 0]);
        }
        return redirect()->back()->with('')->with('message', 'Questão corrigida com sucesso!');
    }
    
    
    
    
}
<file_sep>/app/Conteudo.php
<?php

namespace App;

use App\Entities\Favorito\Favorito;
use App\Generals\Presenter\Conteudos\ConteudoPresenter;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

use Carbon\Carbon;
use Laracasts\Presenter\PresentableTrait;

class Conteudo extends Model
{
    use PresentableTrait;
    protected $presenter = ConteudoPresenter::class;

    //Preenchiveis
    protected $fillable = [
        'id',
        'user_id',
        'titulo',
        'descricao',
        'status',
        'tipo',
        'conteudo',
        'tempo',
        'duracao',
        'apoio',
        'fonte',
        'autores',
        'categoria_id',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'descricao'    => '',
        'status'       => 0,
        'tipo'         => 1,
        'duracao' => 0,
        'apoio'        => '',
        'fonte'        => '',
        'autores'      => '',
        'categoria_id' => 1,
    ];

    public function conteudos_aula()
    {
        return $this->hasMany('App\ConteudoAula', 'conteudo_id');
    }

    public function conteudo_aula()
    {
        return $this->belongsTo('App\ConteudoAula', 'id', 'conteudo_id');
    }

    public function progressos()
    {
        return $this->hasMany('App\ProgressoConteudo', 'conteudo_id')->where('tipo', '=', 2);
    }

    public function progressos_user()
    {
        return $this->hasMany('App\ProgressoConteudo', 'conteudo_id')->with('user')->where('tipo', '=', 2);
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

    public static function detalhado($conteudos)
    {
        foreach ($conteudos as $key => $conteudo) {
            switch ($conteudo->tipo) {
                case 1:
                    $conteudo->tipo_nome = 'Misto';
                    $conteudo->tipo_icon = 'fas fa-font';
                    break;
                case 2:
                    $conteudo->tipo_nome = 'Áudio';
                    $conteudo->tipo_icon = 'fas fa-podcast';
                    break;
                case 3:
                    $conteudo->tipo_nome = 'Vídeo';
                    $conteudo->tipo_icon = 'fa fa-video';
                    break;
                case 4:
                    $conteudo->tipo_nome = 'Slide';
                    $conteudo->tipo_icon = 'fa fa-file-powerpoint';
                    break;
                case 5:
                    $conteudo->tipo_nome = 'Transmissão';
                    $conteudo->tipo_icon = 'fa fa-broadcast-tower';
                    break;
                case 6:
                    $conteudo->tipo_nome = 'Upload';
                    $conteudo->tipo_icon = 'fa fa-upload';
                    break;
                case 7:
                    $conteudo->tipo_nome = 'Dissertativa';
                    $conteudo->tipo_icon = 'fa fa-comment-alt';
                    break;
                case 8:
                    $conteudo->tipo_nome = 'Quiz';
                    $conteudo->tipo_icon = 'fa fa-list-ul';
                    break;
                case 9:
                    $conteudo->tipo_nome = 'Prova';
                    $conteudo->tipo_icon = 'fa fa-stopwatch';
                    break;
                case 10:
                    $conteudo->tipo_nome = 'Entregável';
                    $conteudo->tipo_icon = 'fa fa-arrow-circle-up';
                    break;
                case 11:
                    $conteudo->tipo_nome = 'Livro digital';
                    $conteudo->tipo_icon = 'fa fa-file-alt';
                    break;

                default:
                    $conteudo->tipo_nome = 'Misto';
                    $conteudo->tipo_icon = 'fas fa-font';
                    break;
            }

            Carbon::setLocale('pt-BR');
            $conteudo->date = $conteudo->created_at->formatLocalized('%d de %B de %Y às %H:%M');
        }

        return $conteudos;
    }

    public function favorito($idUser, $idRef)
    {
        return $this->hasOne(Favorito::class, 'referencia_id')
            ->where([['user_id', $idUser], ['referencia_id', $idRef], ['tipo', 2]])->first();
    }

    public function getTipoNomeAttribute()
    {
        switch ($this->tipo) {
            case 1:
                return 'Misto';

                break;
            case 2:
                return 'Áudio';

                break;
            case 3:
                return 'Vídeo';

                break;
            case 4:
                return 'Slide';

                break;
            case 5:
                return 'Transmissão';

                break;
            case 6:
                return 'Upload';

                break;
            case 7:
                return 'Dissertativa';

                break;
            case 8:
                return 'Quiz';

                break;
            case 9:
                return 'Prova';

                break;
            case 10:
                return 'Entregável';

                break;
            case 11:
                return 'Livro digital';

                break;

            default:
                return 'Misto';

                break;
        }
    }

    public function getTipoIconAttribute()
    {
        switch ($this->tipo) {
            case 1:
                return 'fas fa-font';

                break;
            case 2:
                return 'fas fa-podcast';

                break;
            case 3:
                return 'fa fa-video';

                break;
            case 4:
                return 'fa fa-file-powerpoint';

                break;
            case 5:
                return 'fa fa-broadcast-tower';

                break;
            case 6:
                return 'fa fa-upload';

                break;
            case 7:
                return 'fa fa-comment-alt';

                break;
            case 8:
                return 'fa fa-list-ul';

                break;
            case 9:
                return 'fa fa-stopwatch';

                break;
            case 10:
                return 'fa fa-arrow-circle-up';

                break;
            case 11:
                return 'fa fa-file-alt';

                break;

            default:
                return 'fas fa-font';

                break;
        }
    }

}
<file_sep>/app/Http/Controllers/Favoritos/Alunos/FavoritosController.php
<?php

namespace App\Http\Controllers\Favoritos\Alunos;

use App\Entities\Favorito\Favorito;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class FavoritosController extends Controller
{
    public function index()
    {
        $favoritos = Favorito::where('user_id', Auth::user()->id)->get();
        return view('pages.favoritos.alunos.index', compact('favoritos'));
    }


    public function adiciona($idRef, $tipo)
    {
        if (Favorito::where([['user_id', Auth::user()->id], ['referencia_id', $idRef], ['tipo', $tipo]])->exists() === true) {
            return redirect()->route('biblioteca')->withErrors(['Este conteúdo já foi adicionado aos seus favoritos']);
        }
        Favorito::create([
            'user_id'       => Auth::user()->id,
            'referencia_id' => $idRef,
            'tipo'          => $tipo
        ]);
        return redirect()->route('biblioteca')->with('message', 'Conteúdo adicionado aos favoritos!');
    }


    public function search(Request $request)
    {
        $favoritos = Favorito::where('user_id', Auth::user()->id)
            ->with('conteudo')
            ->whereHas('conteudo', function ($query) use ($request) {
                $query->where('titulo', 'LIKE', '%' . $request->get('search') . '%');
            })->get();
        return view('pages.favoritos.alunos.index', compact('favoritos'));
    }


}
<file_sep>/app/Http/Controllers/Ranking/Alunos/RankingController.php
<?php

namespace App\Http\Controllers\Ranking\Alunos;

use App\AlunoTurma;
use App\Entities\GamificacaoUsuario\GamificacaoUsuario;
use App\Escola;
use App\Turma;
use App\User;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class RankingController extends Controller
{

    public function index()
    {
        $usersXps = User::with('gamificacao')
        // where([['permissao', '=', 'A']])
        ->get()
        ->sortByDesc('gamificacao.xp')->values();

        // $usersXps = GamificacaoUsuario::select('user_id', 'xp')
        //     ->orderBy('xp', 'DESC')
        //     ->limit(20)
        //     ->get();

        $escolas = Escola::all();

        foreach ($escolas as $key => $escola)
        {
            $total = 0;

            foreach ($escola->alunos as $key => $aluno)
            {
                if($aluno->gamificacao != null)
                {
                    $total += $aluno->gamificacao->sum('xp');
                }
            }

            $escola->xp = $total;
        }

        $escolas = $escolas->sortByDesc('xp')->values();

        $turmas = Turma::with('alunos.user.gamificacao')->whereHas('alunos.user')->get();

        foreach ($turmas as $key => $turma)
        {
            $total = 0;
            foreach ($turma->alunos as $key => $aluno)
            {
                if($aluno->user->gamificacao != null)
                {
                    $total += $aluno->user->gamificacao->sum('xp');
                }
                // $total += 1;
            }

            $turma->xp = $total;
        }

        $turmas = $turmas->sortByDesc('xp')->values();


        $userIndexGet = $usersXps->search(function ($user) {
            return $user->id === Auth::id();
        });

        ($userIndexGet !== false ? $userIndex = $userIndexGet + 1 : $userIndex = $userIndexGet);
        // $userIndex = $userIndexGet;

        $escolaUserIndexGet = $escolas->search(function ($escola) {
            return $escola->id === Auth::user()->escola_id;
        });

        ($escolaUserIndexGet !== false ? $escolaIndex = $escolaUserIndexGet + 1 : $escolaIndex = $escolaUserIndexGet);

        $turmaIndex = null;

        if(AlunoTurma::where('user_id', Auth::user()->id)->exists())
        {
            $turmaIndexGet = $turmas->search(function ($turma) {
                $turmaId = AlunoTurma::where('user_id', Auth::user()->id)->first();
                return $turma->id === $turmaId->turma_id;
            });

            ($turmaIndexGet !== false ? $turmaIndex = $turmaIndexGet + 1 : $turmaIndex = $turmaIndexGet);
        }

        // $userLogged = GamificacaoUsuario::where('user_id', Auth::id())->first();
        $userLogged = Auth::user()->with('gamificacao');

        $idUserTurma = null;

        if(AlunoTurma::where('user_id', Auth::user()->id)->exists())
        {
            $idUserTurma = AlunoTurma::where('user_id', Auth::user()->id)->first()->turma_id;
        }


        return view('pages.ranking.alunos.index', compact('usersXps', 'userIndex', 'turmaIndex', 'idUserTurma', 'userLogged', 'escolas', 'turmas', 'escolaIndex'));
    }

}
<file_sep>/app/Http/Controllers/Importacao/ImportacaoController.php
<?php
namespace App\Http\Controllers\Importacao;

class ImportacaoController
{
    
}<file_sep>/app/Entities/Roteiros/RoteirosTopico.php
<?php

namespace App\Entities\Roteiros;

use App\Roteiro;
use Illuminate\Database\Eloquent\Model;

class RoteirosTopico extends Model
{

    protected $table = "roteiros_topicos";

    //Preenchiveis
    protected $fillable = [
        'titulo',
        'roteiro_id',
        'status',
    ];

    public $topicosAtivos;
    public $topicosInativos;

    //atributos
    protected $attributes = [
    ];


    public function topico()
    {
        return $this->belongsTo(Roteiros::class, 'roteiro_id');
    }
    
}
<file_sep>/app/Entities/HabilidadeUsuario/HabilidadeUsuario.php
<?php

namespace App\Entities\HabilidadeUsuario;

use App\Entities\Habilidade\Habilidade;
use App\User;
use Illuminate\Database\Eloquent\Model;

class HabilidadeUsuario extends Model
{
  protected $table = "habilidade_usuario";
  
  //Preenchiveis
  protected $fillable = [
    'habilidade_id',
    'user_id',
    'pontos'
  ];
  
  public function habilidade()
  {
    return $this->belongsTo(Habilidade::class);
  }
  
  public function user()
  {
    return $this->belongsTo(User::class, 'user_id');
  }
  
}
<file_sep>/app/Http/Controllers/Exportacao/AulaConteudoController.php
<?php
namespace App\Http\Controllers\Exportacao;

use App\Conteudo;

class AulaConteudoController extends ExportacaoController
{

    public function aulaConteudo($idCurso, $idAula, $idConteudo)
    {
        $aulaConteudo = Conteudo::find($idConteudo);
        $aulaConteudo->makeHidden(['id', 'user_id', 'created_at', 'updated_at']); //LISTA DE CAMPOS QUE NÃO PRECISAMOS CAPTURAR.
       
        $res['aula_conteudo'] = $aulaConteudo;

        $res = json_encode($res);        

        $fileName = $this->generateFileName('aula_conteudo', $aulaConteudo->titulo, 'tz');

        return $this->callDownloadFromStream($res, $fileName, '');
    }

}<file_sep>/app/Services/GamificacaoService.php
<?php

namespace App\Services;

use Auth;

use App\User;
use App\Notificacao;

use App\Entities\GamificacaoUsuario\GamificacaoUsuario;

use App\Entities\ConfiguracoesGamificacao\ConfiguracoesGamificacao;

class GamificacaoService {


    //
    // Gatilhos de incremento da plataforma
    //

    //
    // loginIncrement()
    // conteudoCompletoIncrement
    // aulaConcluidaIncrement()
    // cursoConcluidoIncrement()
    // testeConcluidaIncrement()
    // topicoCriadoIncrement()
    // comentarioEnviadoIncrement()
    //

    public static function loginIncrement()
    {
        $configuracoes_gamificacao = ConfiguracoesGamificacao::where([['escola_id', '=', Auth::user()->escola_id]])->first();

        // dd($configuracoes_gamificacao);

        if($configuracoes_gamificacao == null)
        {
            return true;
        }


        if($configuracoes_gamificacao->login_ativo == true)
        {
            self::incrementUserXP($configuracoes_gamificacao->login_xp);
        }

        return true;
    }

    public static function conteudoCompletoIncrement()
    {
        $configuracoes_gamificacao = ConfiguracoesGamificacao::where([['escola_id', '=', Auth::user()->escola_id]])->first();

        if($configuracoes_gamificacao == null)
        {
            return true;
        }

        if($configuracoes_gamificacao->conclusao_conteudo_ativo == true)
        {
            self::incrementUserXP($configuracoes_gamificacao->conclusao_conteudo_xp);
        }

        return true;
    }

    public static function aulaConcluidaIncrement()
    {
        $configuracoes_gamificacao = ConfiguracoesGamificacao::where([['escola_id', '=', Auth::user()->escola_id]])->first();

        if($configuracoes_gamificacao == null)
        {
            return true;
        }

        if($configuracoes_gamificacao->conclusao_aula_ativo == true)
        {
            self::incrementUserXP($configuracoes_gamificacao->conclusao_aula_xp);
        }

        return true;
    }

    public static function cursoConcluidoIncrement()
    {
        $configuracoes_gamificacao = ConfiguracoesGamificacao::where([['escola_id', '=', Auth::user()->escola_id]])->first();

        if($configuracoes_gamificacao == null)
        {
            return true;
        }

        if($configuracoes_gamificacao->conclusao_curso_ativo == true)
        {
            self::incrementUserXP($configuracoes_gamificacao->conclusao_curso_xp);
        }

        return true;
    }

    public static function testeConcluidaIncrement()
    {
        $configuracoes_gamificacao = ConfiguracoesGamificacao::where([['escola_id', '=', Auth::user()->escola_id]])->first();

        if($configuracoes_gamificacao == null)
        {
            return true;
        }

        if($configuracoes_gamificacao->conclusao_teste_ativo == true)
        {
            self::incrementUserXP($configuracoes_gamificacao->conclusao_teste_xp);
        }

        return true;
    }

    public static function topicoCriadoIncrement()
    {
        $configuracoes_gamificacao = ConfiguracoesGamificacao::where([['escola_id', '=', Auth::user()->escola_id]])->first();

        if($configuracoes_gamificacao == null)
        {
            return true;
        }

        if($configuracoes_gamificacao->topico_ativo == true)
        {
            self::incrementUserXP($configuracoes_gamificacao->topico_xp);
        }

        return true;
    }

    public static function comentarioEnviadoIncrement()
    {
        $configuracoes_gamificacao = ConfiguracoesGamificacao::where([['escola_id', '=', Auth::user()->escola_id]])->first();

        if($configuracoes_gamificacao == null)
        {
            return true;
        }

        if($configuracoes_gamificacao->comentario_ativo == true)
        {
            self::incrementUserXP($configuracoes_gamificacao->comentario_xp);
        }

        return true;
    }

    //
    // Helper functions
    //

    public static function incrementUserXP($amount)
    {
        if(($amount > 0) == false)
        {
            return null;
        }
        else if(Auth::check() == false)
        {
            return null;
        }

        $gamificacao_usuario = GamificacaoUsuario::where('user_id', Auth::user()->id)->first();

        // $gamificacao_usuario->delete();

        // dd($gamificacao_usuario);

        if ($gamificacao_usuario == null)
        {
            $gamificacao_usuario = GamificacaoUsuario::create(['user_id' => Auth::user()->id, 'xp' => 0]);
        }

        if((Auth::user()->gamificacao->xp_reseted + $amount) >= Auth::user()->gamificacao->next_level_xp(true))
        {
            $level_up = true;
        }
        else
        {
            $level_up = false;
        }

        $new_level = Auth::user()->gamificacao->getLevel( Auth::user()->gamificacao->xp + $amount );

        if($level_up)
        {
            Notificacao::create([
                'user_id' => Auth::user()->id,
                'titulo' => "Parabéns!",
                'descricao' => "Você alcançou o nível " . ( $new_level ),
                'tipo' => 2,
            ]);

            $gamificacao_usuario->update([
                "notificado_level_up" => false
            ]);
        }

        $gamificacao_usuario->update([
            'xp' => ($gamificacao_usuario->xp + $amount)
        ]);

        // return Auth::user()->gamificacao->level_atual() . ', ' . $new_level . ', ' .  Auth::user()->gamificacao->xp . ', ' .  $amount . '<br>' . Auth::user()->gamificacao->getLevel( (Auth::user()->gamificacao->xp + $amount) );

        return $gamificacao_usuario;
    }

    public static function showLevelUpNotification()
    {
        if(Auth::check() == false)
        {
            return null;
        }

        $gamificacao_usuario = GamificacaoUsuario::where('user_id', Auth::user()->id)->first();

        if ($gamificacao_usuario == null)
        {
            $gamificacao_usuario = GamificacaoUsuario::create(['user_id' => Auth::user()->id, 'xp' => 0]);
        }

        if($gamificacao_usuario->notificado_level_up == false)
        {
           $gamificacao_usuario->update([
                "notificado_level_up" => true
            ]);

            $new_level = $gamificacao_usuario->level_atual();

            return view('components.gamificacao.level-up-popup')->with( compact('new_level') );
        }
        else
        {
            return null;
        }

    }

}
<file_sep>/app/Curso.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class Curso extends Model
{
    //Preenchiveis
    protected $fillable = [
        'escola_id',
        'user_id',
        'titulo',
        'descricao_curta',
        'descricao',
        'capa',
        'categoria',
        'tipo',
        'visibilidade',
        'senha',
        'status',
        'preco',
        'periodo',
        'vagas',
        'data_publicacao',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'escola_id' => 1,
        'capa' => '',
        'categoria' => 1,
        'tipo' => 1,
        'visibilidade' => 1,
        'senha' => '',
        'status' => 0,
        'preco' => 0,
        'periodo' => 0,
        'vagas' => 0,
    ];

    //
    // Tipos
    //
    // 1 = Curso padrão / Para alunos
    // 2 = Curso para professores / gestores (oculto do catalogo)
    //

    //
    // Mutators
    //
    public function getMatriculadosAttribute()
    {
        return Matricula::where('curso_id', '=', $this->id)->count();
    }

    public function getStatusNameAttribute()
    {
        switch ($this->status)
        {
            case 0:
                return 'Rascunho';
                break;
            case 1:
                return 'Publicado';
                break;

            default:
                return 'Rascunho';
                break;
        }
    }

    //
    // Relationships
    //

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

    public function matriculas()
    {
        return $this->hasMany('App\Matricula', 'curso_id');
    }

    public function aulas()
    {
        return $this->hasMany('App\Aula', 'curso_id')->orderBy('id', 'asc');
    }

    public function conteudos()
    {
        return $this->hasMany('App\Conteudo', 'curso_id');
    }

    public function avaliacoes()
    {
        return $this->hasMany('App\AvaliacaoCurso', 'curso_id');
    }

    public function avaliacoes_user()
    {
        return $this->hasMany('App\AvaliacaoCurso', 'curso_id')->with('user');
    }

    public function topicos()
    {
        // return $this->hasMany('App\TopicoCurso', 'curso_id')->withCount('comentarios')->withCount('visualizacoes');
        return $this->hasMany('App\TopicoCurso', 'curso_id')->withCount('comentarios');
    }

    public static function TituloUrl($cursos)
    {
        foreach ($cursos as $curso)
        {
            $curso->titulo_url = $curso->titulo;

            if(Curso::where('titulo', '=', $curso->titulo)->count() > 1)
            {
                $curso->titulo_url = $curso->titulo_url . '-' . $curso->id;
            }

            // $curso->titulo_url = urlencode($curso->titulo_url);

            // $curso->titulo_url = preg_replace('/[ ]/', '+', $curso->titulo_url);

            $curso->titulo_url = mb_strtolower($curso->titulo_url, 'UTF-8');
        }

        return $cursos;
    }

}
<file_sep>/app/Http/Controllers/Glossario/Front/GlossarioController.php
<?php

namespace App\Http\Controllers\Glossario\Front;

use App\Entities\Glossario\Repository;
use App\Http\Controllers\Controller;
use Illuminate\Http\Request;

use App\Conteudo;

class GlossarioController extends Controller
{
    private $repository;

    public function __construct(Repository $repository)
    {
        $this->repository = $repository;
    }

    public function index($word = 'A')
    {
        $glossarios = $this->repository->all($word);

        foreach ($glossarios as $key => $value)
        {
            $relacionados = Conteudo::
            where([['titulo', 'like', '%' . $value->word . '%']])
            ->orWhere([['descricao', 'like', '%' . $value->word . '%']])
            ->orWhere([['conteudo', 'like', '%' . $value->word . '%']])
            ->orWhere([['apoio', 'like', '%' . $value->word . '%']])
            ->orWhere([['fonte', 'like', '%' . $value->word . '%']])
            ->orWhere([['autores', 'like', '%' . $value->word . '%']])
            ->get();

            // dd($relacionados);

            $value->relacionados = $relacionados;
        }

        return view('pages.glossario.front.index', compact('glossarios', 'word'));
    }

    public function search(Request $request)
    {
        $word = ucfirst($request->get('word'));
        $glossarios = $this->repository->search($word);

        foreach ($glossarios as $key => $value)
        {
            $relacionados = Conteudo::
            where([['titulo', 'like', '%' . $value->word . '%']])
            ->orWhere([['descricao', 'like', '%' . $value->word . '%']])
            ->orWhere([['conteudo', 'like', '%' . $value->word . '%']])
            ->orWhere([['apoio', 'like', '%' . $value->word . '%']])
            ->orWhere([['fonte', 'like', '%' . $value->word . '%']])
            ->orWhere([['autores', 'like', '%' . $value->word . '%']])
            ->get();

            // dd($relacionados);

            $value->relacionados = $relacionados;
        }

        return view('pages.glossario.front.index', compact('glossarios', 'word'));
    }
}
<file_sep>/app/Entities/TesteNivelamento/TesteNivelamentoRespostaQuestao.php
<?php

namespace App\Entities\TesteNivelamento;

use App\Entities\Questoes\Questoes;
use Illuminate\Database\Eloquent\Model;

class TesteNivelamentoRespostaQuestao extends Model
{
    protected $table = "teste_nivelamento_resposta_questao";
    
    //Preenchiveis
    protected $fillable = [
        'teste_nivelamento_resultado_id',
        'questao_id',
        'user_id',
        'resposta',
        'correta'
    ];
    
    public function questao()
    {
        return $this->belongsTo(Questoes::class, 'questao_id');
    }
    
    public function testeQuestao()
    {
        return $this->belongsTo(TesteNivelamentoQuestao::class, 'questao_id', 'questao_id');
    }
    
}
<file_sep>/app/Http/Controllers/GradeAula/Admin/GradeAulaController.php
<?php

namespace App\Http\Controllers\GradeAula\Admin;

use App\AlunoTurma;

use App\Entities\GradeAula\GradeAula;
use App\Turma;

use Carbon\Carbon;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

use Illuminate\Support\Facades\Redirect;
use Illuminate\Support\Facades\Session;
use MaddHatter\LaravelFullcalendar\Facades\Calendar;

class GradeAulaController extends Controller
{
    private function getCalendar($idTurma)
    {
        $events = [];
        $data = GradeAula::where('user_id', Auth::user()->id)->where('turma_id', $idTurma)->get();
        if ($data->count()) {
            foreach ($data as $key => $value) {
                $opts = [
                    'color'       => "$value->cor",
                    'textColor'   => '#FFFFFF',
                    'description' => $value->descricao,
                    'dow'         => [$value->dia],
                    'ranges'      => [$value->dia => ['start' => "$value->data_inicial", 'end' => '']]
                ];

                if ($value->recorrente == 0)
                {
                    unset($opts['dow']);
                    unset($opts['ranges']);
                }

                $events[] = Calendar::event(
                    $value->titulo,
                    false,
                    $value->data_inicial,
                    $value->data_final,
                    $value->id,
                    $opts
                );
            }
        }
        $calendar = Calendar::addEvents($events)->setOptions([
            'columnFormat'    => 'ddd D',
            'allDaySlot'      => false,
            'defaultView'     => 'agendaWeek',
            'slotLabelFormat' => 'HH:mm',
            'minTime'         => '06:00:00',
            'maxTime'         => '24:00:00',
            'slotDuration'    => '01:00:00',
            'locale'          => 'pt-br',
            'contentHeight'   => 'auto',
            'firstDay'        => 0, // inicia na segunda
        ])->setCallbacks([
            'dayClick'   => 'function(date){
                $(".modal-body #dateCalendarInput").val( date.format("DD/MM/YYYY") );
                $(".modal-body #hourInitialCalendarInput").val( date.format("HH:mm") );
                $(".modal-body #hourFinalCalendarInput").val( date.add(1, "hour").format("HH:mm") );
                $("#novaGrade").modal("show");
            }',
            'eventClick' => 'function(event) {

                $(".modal-body #idCalendar").val( event.id );

                if(event.ranges !== undefined){
                    $("input#dateRangesYes").prop("checked", true);
                }

                if(event.ranges == undefined){
                    $("input#dateRangesNo").prop("checked", true);
                }

                $(".modal-body #editSemana").val(event.start.format("DD/MM/YYYY"));
                $(".modal-body #editHourInitial").val(event.start.format("HH:mm"));
                $(".modal-body #editHourFinal").val(event.end.format("HH:mm"));

                $(".modal-body #removeGrade").attr("data-id", event.id);
                $(".modal-body #tituloCalendar").val( event.title );
                $(".modal-body #descricaoCalendar").val( event.description );
                $(".modal-body #dateShowCalendar").html( event.title + " - " + event.start.format("DD/MM/YYYY [às] HH:mm")  );
                $("#editaGrade").modal("show");
            }'
        ]);

        return $calendar;
    }


    private function checkDate($idTurma, $recorrente, $data, $horaInicial, $horaFinal, $dia)
    {
        $check = GradeAula::where(function ($query) use ($idTurma, $recorrente, $data, $horaInicial, $horaFinal, $dia) {
            if ($recorrente == true) {
                $query->where([['dia', '=', $dia], ['hora_inicial', '>=', $horaInicial], ['hora_inicial', '<=', $horaInicial]]);
                $query->orWhere([['dia', '=', $dia], ['hora_final', '>=', $horaFinal], ['hora_final', '<=', $horaFinal]]);
            } else {
                $query->where([['data', '=', $data], ['hora_inicial', '>=', $horaInicial], ['hora_inicial', '<=', $horaInicial]]);
                $query->orWhere([['data', '=', $data], ['hora_final', '>=', $horaFinal], ['hora_final', '<=', $horaFinal]]);
            }
        })->where('turma_id', $idTurma)->exists();
        return $check;
    }


    public function listar($idTurma)
    {
        $calendar = $this->getCalendar($idTurma);
        if (Turma::find($idTurma) == null) {
            Redirect::back()->withErrors(['Turma não encontrada!']);
        } else {
            $turma = Turma::with('professor', 'postagens_comentarios', 'escola')->find($idTurma);

            if (strpos(Auth::user()->permissao, "G") === false && strpos(Auth::user()->permissao, "Z") === false && $turma->user_id != Auth::user()->id && (AlunoTurma::where([['turma_id', '=', $idTurma], ['user_id', '=', Auth::user()->id]])->first() == null)) {
                Session::flash('error', 'Você não faz parte desta turma!');
                return redirect()->route('catalogo');
            }
            return view('gestao.grades-aula.turmas-grade-aula')->with(compact('turma', 'calendar'));
        }
    }


    public function nova($idTurma, Request $request)
    {
        $this->validate($request, [
            'titulo'       => 'required',
            'data'         => 'required',
            'data_inicial' => 'required',
            'data_final'   => 'required'
        ]);

        // Recupera data do input e coloca no formato Y-m-d
        $date = Carbon::createFromFormat('d/m/Y', $request->get('data'))->format('Y-m-d');

        // Recupera o dia da semana DOW, 1 (para Segunda) até 7 (para Domingo)
        $dow = Carbon::createFromFormat('d/m/Y', $request->get('data'))->format('N');

        $startDate = $date . ' ' . $request->get('data_inicial');
        $finalDate = $date . ' ' . $request->get('data_final');


        //verifica se a hora final selecionada é a mesma que a hora inicial
        if ($request->get('data_inicial') == $request->get('data_final')) {
            return redirect()->back()->withErrors(['A hora final não pode ser a mesma que a hora inicial']);
        }

        // verifica se a data selecionada pode ser gravada
        if ($this->checkDate($idTurma, $request->get('recorrente'), $date, $request->get('data_inicial'), $request->get('data_final'), $dow)) {
            return redirect()->back()->withErrors(['Esta data e horário já está sendo usada']);
        }


        GradeAula::create([
            'user_id'      => Auth::user()->id,
            'turma_id'     => $idTurma,
            'titulo'       => $request->get('titulo'),
            'descricao'    => $request->get('descricao'),
            'data'         => $date,
            'data_inicial' => $startDate,
            'data_final'   => $finalDate,
            'hora_inicial' => $request->get('data_inicial'),
            'hora_final'   => $request->get('data_final'),
            'recorrente'   => $request->get('recorrente'),
            'dia'          => $dow,
            'cor'          => $request->get('cor')
        ]);

        return redirect()->route('gestao.grade-listar', $idTurma)->with('message', 'Grade de aula cadastrada com sucesso!');
    }


    public function atualizar(Request $request)
    {
        $this->validate($request, ['titulo' => 'required']);

        //verifica se a hora final selecionada é a mesma que a hora inicial
        if ($request->get('data_inicial') == $request->get('data_final')) {
            return redirect()->back()->withErrors(['A hora final não pode ser a mesma que a hora inicial']);
        }

        $grade_aula = GradeAula::find($request->get('id'));

        $cor = $grade_aula->cor;
        if ($request->get('cor')) {
            $cor = $request->get('cor');
        }

        // Recupera data do input e coloca no formato Y-m-d
        $date = Carbon::createFromFormat('d/m/Y', $request->get('data'))->format('Y-m-d');

        // Recupera o dia da semana DOW, 1 (para Segunda) até 7 (para Domingo)
        $dow = Carbon::createFromFormat('d/m/Y', $request->get('data'))->format('N');

        $startDate = $date . ' ' . $request->get('data_inicial');
        $finalDate = $date . ' ' . $request->get('data_final');

        $grade_aula->update([
            'titulo'       => $request->get('titulo'),
            'descricao'    => $request->get('descricao'),
            'data'         => $date,
            'data_inicial' => $startDate,
            'data_final'   => $finalDate,
            'hora_inicial' => $request->get('data_inicial'),
            'hora_final'   => $request->get('data_final'),
            'cor'          => $cor,
            'recorrente'   => $request->get('recorrente'),
            'dia'          => $dow
        ]);
        return redirect()->route('gestao.grade-listar', $request->get('idTurma'))->with('message', 'Grade de aula cadastrada com sucesso!');
    }


    public function deletar(Request $request)
    {
        GradeAula::find($request->get('idGrade'))->delete();
        return redirect()->back()->with('message', 'Registro excluído com sucesso!');
    }
}
<file_sep>/app/Entities/BadgeUsuario/Api/Repository.php
<?php

namespace App\Entities\BadgeUsuario\Api;


use App\BadgeUsuario;

class Repository
{
  private $badgeUsuario;
  
  public function __construct(BadgeUsuario $badgeUsuario)
  {
    $this->badgeUsuario = $badgeUsuario;
  }
  
  public function store($values)
  {
    return $this->badgeUsuario->create($values);
  }
  
}<file_sep>/app/Aula.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
// use Awobaz\Compoships\Database\Eloquent\Model;

use Illuminate\Support\Facades\Input;

class Aula extends Model
{
    // use \Awobaz\Compoships\Compoships;

    //Preenchiveis
    protected $fillable = [
        'id',
        'curso_id',
        'user_id',
        'titulo',
        'descricao',
        'duracao',
        'requisito',
        'requisito_id',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'descricao' => '',
        'duracao' => 0,
        'requisito' => '',
        'requisito_id' => 0,
    ];

    public static function withConteudos($aula)
    {
        return ConteudoAula::
        with('conteudo')
        ->where([['curso_id', '=', $aula->curso_id], ['aula_id', '=', $aula->id]])
        ->whereHas('conteudo')
        ->get()
        ->sortBy('ordem');

        // return Conteudo::
        // with('conteudo_aula')
        // ->whereHas('conteudo_aula', function ($query) use ($aula) {
        //     $query->where([['curso_id', '=', $aula->curso_id], ['aula_id', '=', $aula->id]]);
        // })
        // ->get()
        // ->sortBy('conteudo_aula.ordem');
    }

    public function curso()
    {
        return $this->belongsTo('App\Curso', 'curso_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/Entities/Glossario/Repository.php
<?php

namespace App\Entities\Glossario;


class Repository
{
  private $glossario;
  
  public function __construct(Glossario $glossario)
  {
    $this->glossario = $glossario;
  }
  
  public function all($word)
  {
    return $this->glossario
      ->where('key', $word)
      ->orderBy('word', 'ASC')
      ->get();
  }
  
  public function search($word)
  {
    return $this->glossario
      ->where('word', 'like', '%' . $word . '%')
      ->orWhere('description', 'like', '%' . $word . '%')
      ->orderBy('word', 'ASC')
      ->get();
  }
  
  public function store($values)
  {
    return $this->glossario->create($values);
  }
}<file_sep>/app/PostagemEscola.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class PostagemEscola extends Model
{
    protected $table = 'postagem_escola';

    //Preenchiveis
    protected $fillable = [
        'id',
        'escola_id',
        'user_id',
        'conteudo',
        'arquivo',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [

    ];

    public function comentarios()
    {
        return $this->hasMany('App\ComentarioPostagemEscola', 'postagem_id');
    }

    public function escola()
    {
        return $this->belongsTo('App\Escola', 'escola_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/database/migrations/2019_08_08_111945_create_aplicacoes_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateAplicacoesTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('aplicacoes', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('user_id');
			$table->string('titulo');
			$table->text('descricao', 65535);
			$table->integer('status');
			$table->integer('liberada');
			$table->boolean('destaque');
			$table->dateTime('data_lancamento')->nullable();
			$table->string('capa');
			$table->integer('categoria_id');
			$table->string('nivel_ensino')->nullable();
			$table->string('ano_serie')->nullable();
			$table->text('tags', 65535)->nullable();
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('aplicacoes');
	}

}
<file_sep>/database/migrations/2019_08_08_111945_create_conteudo_completo_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateConteudoCompletoTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('conteudo_completo', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('curso_id');
			$table->integer('aula_id');
			$table->integer('conteudo_id');
			$table->integer('user_id');
			$table->text('resposta', 65535)->nullable();
			$table->text('correta', 65535)->nullable();
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('conteudo_completo');
	}

}
<file_sep>/app/Http/Controllers/ArtigoAjudaController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Illuminate\Support\Facades\Storage;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\User;

use App\ArtigoAjuda;
use App\AvaliacaoArtigoAjuda;

class ArtigoAjudaController extends Controller
{
    public function index()
    {
        if(Input::get('qt') == null)
            $amount = 10;
        else
            $amount = Input::get('qt');

        if(Input::get('pesquisa') != null)
            $pesquisa = Input::get('pesquisa');

        if(isset($pesquisa))
        {
            $artigos = ArtigoAjuda::with('user')->where('id', 'like', '%' . $pesquisa . '%')->
                orWhere('titulo', 'like', '%' . $pesquisa . '%')->
                orWhere('conteudo', 'like', '%' . $pesquisa . '%')->
            paginate($amount);
        }
        else
        {
            $artigos = ArtigoAjuda::with('user');
        }

        $artigos = $artigos->where([['status', '=', 1]]);

        $artigos = $artigos->paginate($amount);

        return view('ajuda.artigos')->with( compact('artigos', 'amount') );
    }

    public function artigo($idArtigo)
    {
        if(ArtigoAjuda::find($idArtigo) != null)
        {
            $artigo = ArtigoAjuda::with('user', 'avaliacoes_user')->find($idArtigo);

            if($artigo->status != 1 && ((\Auth::user() ? \Auth::user()->permissao == "Z" : false) || (\Auth::user() ? \Auth::user()->id == $artigo->user_id : false)))
            {
                return redirect()->back()->withErrors("Artigo não encontrado!");
            }

            $artigo->marcadores = implode(";", json_decode($artigo->marcadores));
        }
        else
        {
            return redirect()->back()->withErrors("Artigo não encontrado!");
        }

        return view('ajuda.artigo')->with( compact('artigo') );
    }

    public function postAvaliarArtigo($idArtigo, Request $request)
    {
        // return response()->json(["error" => $request->all()]);

        if(Auth::check())
        {
            if(ArtigoAjuda::find($idArtigo) != null)
            {
                AvaliacaoArtigoAjuda::updateOrCreate([
                    'artigo_ajuda_id' => $idArtigo,
                    'user_id' => Auth::user()->id,
                ],
                [
                    'artigo_ajuda_id' => $idArtigo,
                    'user_id' => Auth::user()->id,
                    'avaliacao' => $request->avaliacao
                ]);

                return response()->json(["success" => "Artigo avaliado com sucesso!"]);
            }
            else
            {
                return response()->json(["success" => "Artigo não encontrado!"]);
            }
        }
        else
        {
            return response()->json(["error" => "Para avaliar um artigo você precisa estar logado!"]);
        }
    }

    public function postPesquisar(Request $request)
    {
        if($request->pesquisa != null)
        {
            $artigos = ArtigoAjuda::with('user')->where('id', 'like', '%' . $request->pesquisa . '%')
                ->orWhere('titulo', 'like', '%' . $request->pesquisa . '%')
                ->orWhere('conteudo', 'like', '%' . $request->pesquisa . '%')
                ->get();
        }
        else
        {
            $artigos = ArtigoAjuda::with('user')->all();
        }

        return response()->json(["success" => "Pesquisa concluída com sucesso!", "artigos" => $artigos]);

    }

    public function getAdmin()
    {
        if(Input::get('qt') == null)
            $amount = 10;
        else
            $amount = Input::get('qt');

        if(Input::get('pesquisa') != null)
            $pesquisa = Input::get('pesquisa');

        if(isset($pesquisa))
        {
            $artigos = ArtigoAjuda::with('user')->where('id', 'like', '%' . $pesquisa . '%')->
                orWhere('titulo', 'like', '%' . $pesquisa . '%')->
                orWhere('conteudo', 'like', '%' . $pesquisa . '%')->
            paginate($amount);
        }
        else
        {
            $artigos = ArtigoAjuda::with('user')->paginate($amount);

            foreach ($artigos as $key => $artigo)
            {
                $artigo->total_negativo = AvaliacaoArtigoAjuda::where('artigo_ajuda_id', $artigo->id)->where('avaliacao', -1)->count();
                $artigo->total_neutro = AvaliacaoArtigoAjuda::where('artigo_ajuda_id', $artigo->id)->where('avaliacao', 0)->count();
                $artigo->total_positivo = AvaliacaoArtigoAjuda::where('artigo_ajuda_id', $artigo->id)->where('avaliacao', 1)->count();
                $artigo->total_avaliacoes = AvaliacaoArtigoAjuda::where('artigo_ajuda_id', $artigo->id)->count();

                // dd($artigo);
            }
        }

        return view('gestao.ajuda.artigos')->with( compact('artigos', 'amount') );
    }

    public function postNovo(Request $request)
    {
        if($request->marcadores == null)
        {
            $request->marcadores = [];
        }
        else
        {
            $request->marcadores = explode(';', $request->marcadores);
        }

        // dd(gettype($request->marcadores));

        $request->validate([
            'titulo' => 'required|max:255',
            'conteudo' => 'required',
            'categoria' => 'required',
        ]);

        ArtigoAjuda::create([
            'user_id' => Auth::user()->id,
            'titulo' => $request->titulo,
            'conteudo' => $request->conteudo,
            'categoria' => $request->categoria,
            'marcadores' => json_encode($request->marcadores, JSON_UNESCAPED_UNICODE),
            'status' => $request->status,
        ]);

        \Session::flash("success", "Artigo criado com sucesso!");

        return redirect()->back();
    }

    public function postAtualizar(Request $request)
    {
        if(ArtigoAjuda::find($request->id) != null)
        {
            $artigo = ArtigoAjuda::find($request->id);
        }
        else
        {
            return redirect()->back()->withErrors(["error" => 'Artigo não encontrado!']);
        }

        if($request->marcadores == null)
        {
            $request->marcadores = [];
        }
        else
        {
            $request->marcadores = explode(';', $request->marcadores);
        }

        $request->validate([
            'titulo' => 'required|max:255',
            'conteudo' => 'required',
            'categoria' => 'required',
        ]);

        $artigo->update([
            'titulo' => $request->titulo,
            'conteudo' => $request->conteudo,
            'categoria' => $request->categoria,
            'marcadores' => json_encode($request->marcadores, JSON_UNESCAPED_UNICODE),
            'status' => $request->status,
        ]);

        \Session::flash("success", "Artigo atualizado com sucesso!");

        return redirect()->back();
    }

    public function getArtigo($idArtigo)
    {
        if(ArtigoAjuda::find($idArtigo) != null)
        {
            $artigo = ArtigoAjuda::find($idArtigo);

            $artigo->marcadores = implode(";", json_decode($artigo->marcadores));

            $artigo->total_negativo = AvaliacaoArtigoAjuda::where('artigo_ajuda_id', $artigo->id)->where('avaliacao', -1)->count();
            $artigo->total_neutro = AvaliacaoArtigoAjuda::where('artigo_ajuda_id', $artigo->id)->where('avaliacao', 0)->count();
            $artigo->total_positivo = AvaliacaoArtigoAjuda::where('artigo_ajuda_id', $artigo->id)->where('avaliacao', 1)->count();
            $artigo->total_avaliacoes = AvaliacaoArtigoAjuda::where('artigo_ajuda_id', $artigo->id)->count();

            return response()->json(["success" => 'Artigo carregado com sucesso!', "artigo" => $artigo]);
        }
        else
        {
            return response()->json(["error" => 'Artigo não encontrado!']);
        }
    }

    public function getDeletarArtigo($idArtigo)
    {
        if(ArtigoAjuda::find($idArtigo) != null)
        {
            $artigo = ArtigoAjuda::find($idArtigo);

            AvaliacaoArtigoAjuda::where('artigo_ajuda_id', $artigo->id)->delete();

            $artigo->delete();

            return response()->json(["response" => true, "data" => 'Artigo deletado com sucesso!', "artigo" => $artigo, 200]);
        }
        else
        {
            return response()->json(["response" => false, "data" => 'Artigo não encontrado!', 404]);
        }
    }

}


<file_sep>/app/Http/Controllers/MarcadorPagina/MarcadorPaginaController.php
<?php

namespace App\Http\Controllers\MarcadorPagina;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;

use Redirect;
use Session;
use Auth;

use App\User;

use App\Conteudo;

use App\Entities\Anotacao\Anotacao;
use App\Entities\MarcadorPagina\MarcadorPagina;

class MarcadorPaginaController extends Controller
{
    public function paginaMarcada($conteudo_id)
    {
        $paginaMarcada = null;

        if(MarcadorPagina::where([['user_id', '=', Auth::id()], ['conteudo_id', '=', $conteudo_id]])->exists())
        {
            $paginaMarcada = MarcadorPagina::where([['user_id', '=', Auth::id()], ['conteudo_id', '=', $conteudo_id]])->latest()->first()->pagina;
        }

        return response()->json(['response' => true, "paginaMarcada" => $paginaMarcada]);
    }

    public function marcarPagina($conteudo_id, $paginaAtual)
    {
        // if(MarcadorPagina::where([['user_id', '=', Auth::id()], ['conteudo_id', '=', $conteudo_id], ['pagina', '=', $paginaAtual]])->first() == null)
        // {
        //     MarcadorPagina::create([
        //         'user_id' => Auth::id(),
        //         'conteudo_id' => $conteudo_id,
        //         'pagina' => $paginaAtual,
        //     ]);
        // }

        MarcadorPagina::updateOrCreate(
            [
                'user_id' => Auth::id(), 'conteudo_id' => $conteudo_id
            ],
            [
                'pagina' => $paginaAtual
        ]);

        return response()->json(['success' => 'Pagina marcada com sucesso!']);
    }

    public function deletarMarcador($conteudo_id, $pagina)
    {
        if(MarcadorPagina::where([['user_id', '=', Auth::id()], ['conteudo_id', '=', $conteudo_id], ['pagina', '=', $pagina]])->first() != null)
        {
            MarcadorPagina::where([['user_id', '=', Auth::id()], ['conteudo_id', '=', $conteudo_id], ['pagina', '=', $pagina]])->first()->delete();
        }

        return response()->json(['success' => 'Marcador deletado com sucesso!']);
    }
}
<file_sep>/app/Http/Controllers/User/Api/UserApiController.php
<?php

namespace App\Http\Controllers\User\Api;

use App\User;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class UserApiController extends controller
{
    public function getInstrutor($id)
    {
        try {
            $user = User::where('id', $id)
                //->with('albuns')
                ->with(['albuns' => function ($query) {
                    $query->select('albums.id', 'albums.titulo', 'albums.capa as url', 'albums.descricao',
                        'albums.categoria', 'albums.user_id as artist', 'albums.user_id', 'albums.created_at');
                }])
                ->select('users.id', 'users.name', 'users.email', 'users.img_perfil', 'users.descricao')
                ->first();
            return response()->json($user);
        } catch (\Exception $exception) {
            return response()->json(['error' => 'Erro ao listar Instrutor', 'message:' => $exception->getMessage()]);
        }
    }
}

<file_sep>/app/Artigo.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

use Carbon\Carbon;


class Artigo extends Model
{
    //Preenchiveis
    protected $fillable = [
        'id',
        'user_id',
        'escola_id',
        'titulo',
        'subtitulo',
        'descricao',
        'conteudo',
        'capa',
        'status',
        'categoria_id',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'escola_id' => 1,
        'status' => 0,
        'categoria_id' => 1,
    ];

    public function categoria()
    {
        return $this->belongsTo('App\Categoria', 'categoria_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }
}
<file_sep>/database/migrations/2019_08_08_111945_create_anotacoes_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateAnotacoesTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('anotacoes', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('user_id');
			$table->integer('conteudo_id');
			$table->integer('pagina');
			$table->text('trecho');
			$table->text('anotacao');
			$table->string('pos_y', 20);
			$table->string('pos_x', 20);
			$table->integer('start');
			$table->integer('end');
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('anotacoes');
	}

}
<file_sep>/app/Http/Controllers/GestaoController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;
use Illuminate\Support\Facades\DB;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\AvaliacaoInstrutor;
use App\AlunoTurma;
use App\Entities\GamificacaoUsuario\GamificacaoUsuario;
use App\Turma;
use App\User;


use App\Escola;
use App\Conteudo;
use App\Aplicacao;
use App\Categoria;

use App\Curso;
use App\Aula;
use App\ConteudoAula;
use App\Matricula;


class GestaoController extends Controller
{
    public function index()
    {
        // return redirect()->route('gestao.biblioteca');

        return redirect()->route('gestao.cursos');
    }

    public function biblioteca()
    {
        $conteudos = Conteudo::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $conteudos = Conteudo::when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        })
        ->get();

        $aplicacoes = Aplicacao::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $aplicacoes = Aplicacao::when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        })
        ->get();

        $videos = $conteudos->filter(function ($c) {
            return $c->tipo == 3;
        });

        $slides = $conteudos->filter(function ($c) {
            return ($c->tipo == 4 && (strpos($c->conteudo, ".ppt") !== false || strpos($c->conteudo, ".pptx") !== false));
        });

        $documentos = $conteudos->filter(function ($c) {
            return $c->tipo == 1 || ($c->tipo == 4 && (strpos($c->conteudo, ".ppt") == false && strpos($c->conteudo, ".pptx") == false));
        });

        $apostilas = $conteudos->filter(function ($c) {
            return $c->tipo == 11;
        });

        return view('gestao.biblioteca')->with(compact('conteudos', 'videos', 'slides', 'apostilas', 'documentos', 'aplicacoes'));
    }

    public function postNovoConteudo(Request $request)
    {
        // dd($request);

        if($request->descricao == null)
        {
            $request->descricao = '';
        }

        if($request->obrigatorio == null)
        {
            $request->obrigatorio = 0;
        }
        elseif($request->obrigatorio == 'on')
        {
            $request->obrigatorio = 1;
        }

        if($request->tempo == null)
        {
            $request->tempo = 0;
        }

        if($request->fonte == null)
        {
            $request->fonte = '';
        }

        if($request->autores == null)
        {
            $request->autores = '';
        }

        switch ($request->tipo)
        {
            case 1:
                $conteudo = $request->conteudo;
                break;

            case 2:
                if(isset($request->arquivoAudio))
                    $request->arquivo = $request->arquivoAudio;
                else
                    $request->conteudo = $request->conteudoAudio;
                break;

            case 3:
                if(isset($request->arquivoVideo))
                    $request->arquivo = $request->arquivoVideo;
                else
                    $request->conteudo = $request->conteudoVideo;
                break;

            case 4:
                if(isset($request->arquivoSlide))
                    $request->arquivo = $request->arquivoSlide;
                else
                    $request->conteudo = $request->conteudoSlide;
                break;

            default:
                $conteudo = $request->conteudo;
                break;
        }

        if($request->tipo == 2 || $request->tipo == 3 || $request->tipo == 4 || $request->tipo == 6)
        {
            if(isset($request->arquivo))
            {
                $originalName = mb_strtolower( $request->arquivo->getClientOriginalName(), 'utf-8' );

                $fileExtension = \File::extension($request->arquivo->getClientOriginalName());
                $newFileNameArquivo =  md5( $request->arquivo->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

                $pathArquivo = $request->arquivo->storeAs('uploads/conteudos', $newFileNameArquivo, 'local');

                if(!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo)))
                {
                    \Session::flash('error', 'Não foi possível fazer upload de seu conteúdo!');
                }
                else
                {
                    $conteudo = $newFileNameArquivo;
                }
            }
            else
            {
                $conteudo = $request->conteudo;
            }
        }

        $novo_conteudo = Conteudo::create([
            'user_id' => \Auth::user()->id,
            'titulo' => $request->titulo,
            'descricao' => $request->descricao,
            'tipo' => $request->tipo,
            'conteudo' => $conteudo,
            'tempo' => $request->tempo,
            'apoio' => $request->apoio,
            'fonte' => $request->fonte,
            'autores' => $request->autores,
            'status' => $request->status,
        ]);

        return Redirect::route('gestao.biblioteca')->with('message', 'Conteúdo criado com sucesso!');
    }

    public function editarConteudo($idConteudo)
    {
        if(Conteudo::where([['id', '=', $idConteudo]])->first() != null)
        {
            $conteudo = Conteudo::where([['id', '=', $idConteudo]])->first();

            if($conteudo->tipo == 2 || $conteudo->tipo == 3 || $conteudo->tipo == 4 || $conteudo->tipo == 6)
            {
                if(\Storage::disk('local')->has('uploads/conteudos/' . $conteudo->conteudo))
                {
                    $conteudo->temArquivo = true;
                }
                else
                {
                    $conteudo->temArquivo = false;
                }
            }

            return response()->json(['success'=> 'Conteudo encontrado..', 'conteudo' => json_encode($conteudo)]);
        }
        else
        {
            return response()->json(['error' => 'Conteúdo não encontrado!']);
        }
    }

    public function postSalvarConteudo(Request $request)
    {
        // dd($request);

        if(Conteudo::where([['id', '=', $request->idConteudo]])->first() != null)
        {
            $conteudoOriginal = Conteudo::where([['id', '=', $request->idConteudo]])->first();

            if($request->descricao == null)
            {
                $request->descricao = '';
            }

            if($request->obrigatorio == null)
            {
                $request->obrigatorio = 0;
            }
            elseif($request->obrigatorio == 'on')
            {
                $request->obrigatorio = 1;
            }

            if($request->tempo == null)
            {
                $request->tempo = 0;
            }

            if($request->fonte == null)
            {
                $request->fonte = '';
            }

            if($request->autores == null)
            {
                $request->autores = '';
            }

            switch ($request->tipo)
            {
                case 1:
                    $conteudo = $request->conteudo;
                    break;

                case 2:
                    if(isset($request->arquivoAudio))
                        $request->arquivo = $request->arquivoAudio;
                    else
                        $request->conteudo = $request->conteudoAudio;
                    break;
                case 3:
                    if(isset($request->arquivoVideo))
                        $request->arquivo = $request->arquivoVideo;
                    else
                        $request->conteudo = $request->conteudoVideo;
                    break;
                case 4:
                    if(isset($request->arquivoSlide))
                        $request->arquivo = $request->arquivoSlide;
                    else
                        $request->conteudo = $request->conteudoSlide;
                    break;

                default:
                    $conteudo = $request->conteudo;
                    break;
            }

            if($request->tipo == 2 || $request->tipo == 3 || $request->tipo == 4 || $request->tipo == 6)
            {
                if(isset($request->arquivo))
                {
                    if($conteudoOriginal->conteudo != null)
                    {
                        if(\Storage::disk('local')->has('uploads/conteudos/' . $conteudoOriginal->conteudo))
                        {
                            \Storage::disk('local')->delete('uploads/conteudos/' . $conteudoOriginal->conteudo);
                        }
                    }

                    $originalName = mb_strtolower( $request->arquivo->getClientOriginalName(), 'utf-8' );

                    $fileExtension = \File::extension($request->arquivo->getClientOriginalName());
                    $newFileNameArquivo =  md5( $request->arquivo->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

                    $pathArquivo = $request->arquivo->storeAs('uploads/conteudos', $newFileNameArquivo, 'local');

                    if(!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo)))
                    {
                        \Session::flash('error', 'Não foi possível fazer upload de seu conteúdo!');
                    }
                    else
                    {
                        $conteudo = $newFileNameArquivo;
                    }
                }
                else
                {
                    if($request->conteudo != "" && $request->conteudo != null)
                        $conteudo = $request->conteudo;
                    else
                        $conteudo = $conteudoOriginal->conteudo;
                }
            }

            $conteudoOriginal->update([
                'titulo' => $request->titulo,
                'descricao' => $request->descricao,
                'conteudo' => $conteudo,
                'fonte' => $request->fonte,
                'autores' => $request->autores,
                'status' => $request->status,
            ]);

            return Redirect::route('gestao.biblioteca')->with('message', 'Conteúdo atualizado com sucesso!');
        }
        else
        {
            return response()->json(['error' => 'Conteúdo não encontrado!']);
        }
    }

    public function postDuplicarConteudo(Request $request)
    {
        if(Conteudo::where([['id', '=', $request->idConteudo]])->first() != null)
        {
            $newConteudo = Conteudo::where([['id', '=', $request->idConteudo]])->first()->replicate();

            $newConteudo->id = null;
            // $newConteudo->id = Conteudo::max('id') + 1;

            $newConteudo->save();

            \Session::flash('message', 'Conteúdo duplicado com sucesso!');
            return redirect()->route('gestao.biblioteca');
        }
        else
        {
            return Redirect::back()->withErrors(['Conteúdo não encontrado!']);
        }
    }

    public function postExcluirConteudo($idConteudo, Request $request)
    {
        if(Conteudo::find($idConteudo) != null)
        {
            $conteudo = Conteudo::where([['id', '=', $request->idConteudo]])->first();

            if($conteudo->tipo == 2 || $conteudo->tipo == 3 || $conteudo->tipo == 4 || $conteudo->tipo == 6)
            {
                if($conteudo->conteudo != null)
                {
                    if(\Storage::disk('local')->has('uploads/conteudos/' . $conteudo->conteudo))
                    {
                        \Storage::disk('local')->delete('uploads/conteudos/' . $conteudo->conteudo);
                    }
                }
            }

            Conteudo::find($idConteudo)->delete();

            // \Session::flash('message', 'Conteúdo excluído com sucesso!');
            // return redirect()->route('gestao.biblioteca');
            return response()->json(["success" => "Aplicação excluída com sucesso!"]);
        }
        else
        {
            // return Redirect::back()->withErrors(['Conteúdo não encontrado!']);
            return response()->json(["error" => "Aplicação não encontrada!"]);
        }
    }

    public function cursosProfessores()
    {
        $cursos = Curso::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $cursos->when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $is_admin = strtoupper(Auth::user()->permissao) == "Z";

        $cursos->when( $is_admin == false, function ($query) {
            return $query->where([['tipo', '=', 2], ['escola_id', '=', Auth::user()->escola_id], ['user_id', '=', Auth::user()->id]])
            ->orWhere([['tipo', '=', 2], ['user_id', '=', Auth::user()->id]]);
        });

        $cursos->when( $is_admin == true, function ($query) {
            return $query->where([['tipo', '=', 2]]);
        });

        $cursos = $cursos
        ->where([['status', '=', 1]])
        ->orderBy('id', 'DESC')
        ->get();

        // $cursos = $cursos->get();

        return view('gestao.cursos-professores')->with(compact('cursos'));
    }

    public function cursos()
    {
        $cursos = Curso::query();

        $is_admin = strtoupper(Auth::user()->permissao) == "Z";

        $cursos->when($is_admin == false, function ($query) {
            return $query->where([['escola_id', '==', Auth::user()->escola_id], ['user_id', '=', Auth::user()->id]])
            ->orWhere('user_id', '=', Auth::user()->id);
        });

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $cursos->when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $cursos = $cursos->get();

        return view('gestao.cursos')->with(compact('cursos'));
    }

    public function novoCurso()
    {
        $categorias = Categoria::all();

        return view('gestao.novo-curso')->with(compact('categorias'));
    }

    public function postNovoCurso(Request $request)
    {
        if(strtoupper(Auth::user()->permissao) == "E")
        {
            $escola = Escola::where('user_id', '=', Auth::user()->id)->first();
        }

        if(!isset($escola))
        {
            $escola = Escola::find(1);
        }
        elseif($escola == null)
        {
            $escola = Escola::find(1);
        }

        // $escola->caracteristicas = json_decode($escola->caracteristicas);

        if($request->preco == null)
        {
            $request->preco = 0;
        }

        if($request->senha == null)
        {
            $request->senha = '';
        }

        if($request->descricao_curta == null)
        {
            $request->descricao_curta = '';
        }

        if($request->descricao == null)
        {
            $request->descricao = '';
        }

        if(isset($request->escola_id) ? $request->escola_id == null : true)
        {
            $request->escola_id = 1;
        }

        $request->preco = str_replace(".", "", $request->preco);
        $request->preco = str_replace(",", ".", $request->preco);

        $curso = Curso::create([
            'escola_id' => $request->escola_id, //$escola->id,
            'user_id' => \Auth::user()->id,
            'titulo' => $request->titulo,
            'descricao_curta' => $request->descricao_curta,
            'descricao' => $request->descricao,
            'categoria' => $request->categoria,
            'tipo' => ($request->tipo === 1 || $request->tipo === 2) ? $request->tipo : 1,
            'visibilidade' => $request->visibilidade,
            'senha' => $request->senha,
            'preco' => $request->preco,
            'periodo' => $request->periodo,
            'vagas' => $request->vagas,
        ]);

        if($request->capa !=null)
        {
            $fileExtension = \File::extension($request->capa->getClientOriginalName());
            $newFileNameCapa =  md5( $request->capa->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

            $pathCapa = $request->capa->storeAs('cursos/capas', $newFileNameCapa, 'public_uploads');

            if(!\Storage::disk('public_uploads')->put($pathCapa, file_get_contents($request->capa)) )
            {
                \Session::flash('middle_popup', 'Ops! Não foi possivel enviar a capa.');
                \Session::flash('popup_style', 'danger');
            }
            else
            {
                $curso->capa = $newFileNameCapa;

                $curso->save();
            }
        }

        if($request->rascunho == true)
        {
            return redirect()->route('gestao.cursos');
        }
        else
        {
            return redirect()->route('gestao.curso-conteudo', ['idCurso' => $curso->id]);
        }
    }

    public function postSalvarCurso($idCurso, Request $request)
    {
        // dd($request);

        if(strtoupper(Auth::user()->permissao) == "E")
        {
            $escola = Escola::where('user_id', '=', Auth::user()->id)->first();
        }

        if(!isset($escola))
        {
            $escola = Escola::find(1);
        }
        elseif($escola == null)
        {
            $escola = Escola::find(1);
        }

        // $escola->caracteristicas = json_decode($escola->caracteristicas);

        if(Curso::find($idCurso))
        {
            $curso = Curso::find($idCurso);

            // $reques->validate([
            //     'titulo' => 'required|max:255',
            //     'descricao_curta' => 'required|max:255',
            //     'descricao' => 'required',
            //     'categoria' => 'required',
            //     'visibilidade' => 'required',
            //     'senha' => 'required',
            //     'preco' => 'required',
            //     'periodo' => 'required',
            //     'vagas' => 'required|integer|min:0',
            // ]);

            if($request->preco == null)
            {
                $request->preco = 0;
            }

            if($request->senha == null)
            {
                $request->senha = '';
            }

            if($request->preco == null)
            {
                $request->preco = 0;
            }

            if($request->vagas == null)
            {
                $request->vagas = 0;
            }

            if($request->senha == null)
            {
                $request->senha = '';
            }

            if($request->descricao == null)
            {
                $request->descricao = '';
            }

            if(isset($request->escola_id) ? $request->escola_id == null : true)
            {
                $request->escola_id = 1;
            }

            $request->preco = str_replace(".", "", $request->preco);
            $request->preco = str_replace(",", ".", $request->preco);

            $curso->update([
                'escola_id' => $request->escola_id, //$escola->id,
                'titulo' => $request->titulo,
                'descricao_curta' => $request->descricao_curta,
                'descricao' => $request->descricao,
                'categoria' => $request->categoria,
                'tipo' => $request->tipo,
                'visibilidade' => $request->visibilidade,
                'senha' => $request->senha,
                'preco' => $request->preco,
                'periodo' => $request->periodo,
                'vagas' => $request->vagas,
            ]);

            if($request->capa != null)
            {
                $fileExtension = \File::extension($request->capa->getClientOriginalName());
                $newFileNameCapa =  md5( $request->capa->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

                $pathCapa = $request->capa->storeAs('cursos/capas', $newFileNameCapa, 'public_uploads');

                if(!\Storage::disk('public_uploads')->put($pathCapa, file_get_contents($request->capa)) )
                {
                    \Session::flash('middle_popup', 'Ops! Não foi possivel enviar a capa.');
                    \Session::flash('popup_style', 'danger');
                }
                else
                {
                    if($curso->capa != null)
                    {
                        if(\Storage::disk('public_uploads')->has('cursos/capas/' . $curso->capa))
                        {
                            \Storage::disk('public_uploads')->delete('cursos/capas/' . $curso->capa);
                        }
                    }

                    $curso->capa = $newFileNameCapa;

                    $curso->save();
                }
            }

            return Redirect::back()->with('message', 'Curso atualizado com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Curso não encontrado!']);
        }
    }

    public function postExcluirCurso($idCurso)
    {
        if(Curso::find($idCurso))
        {
            if(Curso::find($idCurso)->user_id == Auth::user()->id || strtolower(Auth::user()->permissao) == "z")
            {
                foreach (ConteudoAula::where([['curso_id', '=', $idCurso]])->get() as $key => $conteudo)
                {
                    if($conteudo->tipo == 2 || $conteudo->tipo == 3 || $conteudo->tipo == 4 || $conteudo->tipo == 6)
                    {
                        if($conteudo->conteudo != null)
                        {
                            if(\Storage::disk('local')->has('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo))
                            {
                                \Storage::disk('local')->delete('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo);
                            }

                            // // Google cloud storage
                            // if(\Storage::disk('gcs')->has('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo))
                            // {
                            //     \Storage::disk('gcs')->delete('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo);
                            // }
                        }
                    }

                    $conteudo->delete();
                }

                Aula::where([['curso_id', '=', $idCurso]])->delete();

                Curso::find($idCurso)->delete();

                return Redirect::back()->with('message', 'Curso excluido com sucesso!');
            }
            else
            {
                return Redirect::back()->with('error', 'Ação não permitida!');
            }
        }
        else
        {
            return Redirect::back()->with('error', 'Curso não encontrado!');
        }
    }

    public function postPublicarCurso($idCurso)
    {
        if(Curso::find($idCurso))
        {
            if(Curso::find($idCurso)->status == 0)
            {
                if(\App\ConteudoAula::where('curso_id', '=', $idCurso)->exists() == false)
                {
                    return Redirect::back()->withErrors(['Você não pode publicar um curso sem nenhum conteúdo!']);
                }

                // if(Curso::find($idCurso)->preco > 0 && !WirecardAccount::where('user_id', '=', Auth::user()->id)->exists())
                // {
                //     return Redirect::back()->withErrors(['Você não pode publicar um curso pago, sem antes vincular sua conta Wirecard!']);
                // }

                Curso::find($idCurso)->update([
                    'status' => 1,
                    'data_publicacao' => date('Y-m-d H:i:s'),
                ]);

                return Redirect::back()->with('message', 'Curso publicado com sucesso!');
            }
            else
            {
                Curso::find($idCurso)->update(['status' => 0]);

                return Redirect::back()->with('message', 'Curso despublicado com sucesso!');
            }
        }
        else
        {
            return Redirect::back()->withErrors(['Curso não encontrado!']);
        }
    }

    public function conteudoCurso($idCurso, Request $request)
    {
        $curso = Curso::with('aulas')->find($idCurso);

        // dd($curso);

        if($curso == null)
        {
            return redirect()->route('gestao.cursos');
            // return redirect()->back();
        }

        if($request->aula != null)
        {
            if($curso->aulas->filter(function($item) { return $item->id == \Request::get('aula'); })->first() == null)
            {
                return redirect()->route('gestao.curso-conteudo', ['idCurso' => $idCurso]);
            }
        }

        if($curso->data_publicacao != null && $curso->periodo > 0)
        {
            $curso->data_publicacao = \Carbon\Carbon::parse($curso->data_publicacao);

            $curso->data_expiracao = new \Carbon\Carbon($curso->data_publicacao);
            $curso->data_expiracao->addDays($curso->periodo);

            $curso->periodo_restante = \Carbon\Carbon::now()->diffInDays( $curso->data_expiracao );

            if($curso->data_expiracao->gt( \Carbon\Carbon::now() ) == false)
            {
                $curso->periodo_restante *= -1;
            }

            // dd($curso->data_publicacao);

            // dd($curso->data_expiracao);
        }
        else
        {
            $curso->periodo_restante = 0;
        }

        $curso->matriculados = Matricula::with('user')->where('curso_id', '=', $curso->id)->whereHas('user')->count();

        $curso->vagasRestante = $curso->vagas - $curso->matriculados;

        $categorias = Categoria::all();

        return view('gestao.curso-conteudo')->with(compact('curso', 'categorias'));
    }

    public function postNovaAula($idCurso, Request $request)
    {
        // dd($request);

        if(strtoupper(Auth::user()->permissao) == "E")
        {
            $escola = Escola::where('user_id', '=', Auth::user()->id)->first();
        }

        if(!isset($escola))
        {
            $escola = Escola::find(1);
        }
        elseif($escola == null)
        {
            $escola = Escola::find(1);
        }

        // $escola->caracteristicas = json_decode($escola->caracteristicas);

        if($request->duracao == null)
        {
            $request->duracao = 0;
        }

        if($request->requisito == "aula")
        {
            if($request->aula_especifica == null)
                $request->requisito_id = 0;
            else
                $request->requisito_id = $request->aula_especifica;
        }
        else
        {
            $request->requisito_id = 0;
        }

        $newAula = Aula::create([
            'id' => Aula::where('curso_id', '=', $idCurso)->max('id') + 1,
            'curso_id' => $idCurso,
            'user_id' => \Auth::user()->id,
            'titulo' => $request->titulo,
            'descricao' => $request->descricao,
            'duracao' => $request->duracao,
            'requisito' => $request->requisito,
            'requisito_id' => $request->requisito_id,
        ]);

        return Redirect::route('gestao.curso-conteudo', ['curso' => $idCurso, 'aula' => $newAula->id]);
        // return redirect()->back();
    }

    public function editarAula($idCurso, $idAula)
    {

        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            $aula = Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first();

            return response()->json(['success'=> 'Aula encontrada.', 'aula' => json_encode($aula)]);
            return response()->json(['aula' => $aula]);
        }
        else
        {
            return response()->json(['error' => 'Não encontrado']);
        }
    }

    public function postEditarAula($idCurso, Request $request)
    {
        // dd($request);

        if(Aula::where([['id', '=', $request->idAula], ['curso_id', '=', $idCurso]]) != null)
        {
            if($request->duracao == null)
            {
                $request->duracao = 0;
            }

            if($request->requisito == "aula")
            {
                if($request->aula_especifica == null)
                    $request->requisito_id = 0;
                else
                    $request->requisito_id = $request->aula_especifica;
            }
            else
            {
                $request->requisito_id = 0;
            }

            Aula::where([['id', '=', $request->idAula], ['curso_id', '=', $idCurso]])->update([
                'titulo' => $request->titulo,
                'descricao' => $request->descricao,
                'duracao' => $request->duracao,
                'requisito' => $request->requisito,
                'requisito_id' => $request->requisito_id,
            ]);

            return Redirect::back()->with('message', 'Aula atualizada com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Aula não encontrada!']);
        }
    }

    public function reordenarAula($idCurso, $idAula, $index)
    {
        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->update([
                'id' => 999
            ]);
            Conteudo::where([['aula_id', '=', $idAula], ['curso_id', '=', $idCurso]])->update([
                'aula_id' => 999
            ]);

            if(Aula::where([['id', '=', $index], ['curso_id', '=', $idCurso]])->first() != null)
            {
                Aula::where([['id', '=', $index], ['curso_id', '=', $idCurso]])->update([
                    'id' => $idAula,
                ]);
                Conteudo::where([['aula_id', '=', $index], ['curso_id', '=', $idCurso]])->update([
                    'aula_id' => $idAula
                ]);
            }

            Aula::where([['id', '=', '999'], ['curso_id', '=', $idCurso]])->update([
                'id' => $index
            ]);
            Conteudo::where([['aula_id', '=', '999'], ['curso_id', '=', $idCurso]])->update([
                'aula_id' => $index
            ]);

            return response()->json(['success'=> 'Aula reordenada com sucesso!' . $idAula . '-' . $index]);
        }
        else
        {
            return response()->json(['error' => 'Aula não encontrada!']);
        }
    }

    public function postDuplicarAula($idCurso, Request $request)
    {
        if(Aula::where([['id', '=', $request->idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            $newAula = Aula::where([['id', '=', $request->idAula], ['curso_id', '=', $idCurso]])->first()->withConteudos()->replicate();

            $newAula->id = Aula::where('curso_id', '=', $idCurso)->max('id') + 1;

            foreach ($newAula->conteudos as $key => $conteudo)
            {
                $conteudo = $conteudo->replicate();
                $conteudo->id = $key + 1;
                $conteudo->aula_id = $newAula->id;
                $conteudo->save();
            }

            unset($newAula->conteudos);

            $newAula->save();

            \Session::flash('message', 'Aula duplicada com sucesso!');
            return redirect()->route('gestao.curso-conteudo', ['idCurso' => $idCurso, 'aula' => $request->idAula]);

            // return Redirect::back()->with('message', 'Aula duplicada com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Aula não encontrado!']);
        }
    }

    public function postExcluirAula($idCurso, Request $request)
    {
        if(Aula::where([['id', '=', $request->idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            Aula::where([['id', '=', $request->idAula], ['curso_id', '=', $idCurso]])->delete();

            $conteudosAula = ConteudoAula::where([['aula_id', '=', $request->idAula], ['curso_id', '=', $idCurso]])->get();
            foreach($conteudosAula as $conteudoAula)
            {
                Conteudo::where([['id', '=', $conteudoAula->conteudo_id]])->delete();
            }

            ConteudoAula::where([['aula_id', '=', $request->idAula], ['curso_id', '=', $idCurso]])->delete();

            return Redirect::back()->with('message', 'Aula excluida com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Aula não encontrada!']);
        }
    }

    public function aulaConteudos($idCurso, $idAula)
    {
        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            $aula = Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first();//->withConteudos();

            // $aula->conteudos = Aula::withConteudos($aula);

            $aula->conteudos = ConteudoAula::join('conteudos', 'conteudo_aula.conteudo_id', '=', 'conteudos.id')
            ->whereHas('conteudo')
            ->where([['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]])
            ->get();

            // dd($aula);

            // return response()->json($aula->conteudos);

            $aula->conteudos = Conteudo::detalhado($aula->conteudos);

            // dd($aula);

            return response()->json(['success'=> 'Aula encontrada.', 'aula' => json_encode($aula, JSON_PRETTY_PRINT)]);
            return response()->json(['aula' => $aula]);
        }
        else
        {
            return response()->json(['error' => 'Aula não encontrada!']);
        }
    }

    public function postNovoConteudoCurso($idCurso, Request $request)
    {
        // dd($request);

        if(Aula::where([['id', '=', $request->idAula], ['curso_id', '=', $idCurso]]) != null)
        {
            if($request->descricao == null)
            {
               $request->descricao = '';
            }

            if($request->obrigatorio == null)
            {
               $request->obrigatorio = 0;
            }
            elseif($request->obrigatorio == 'on')
            {
                $request->obrigatorio = 1;
            }

            if($request->tempo == null)
            {
               $request->tempo = 0;
            }

            if($request->apoio == null)
            {
            //    $request->apoio = '';
            }
            else
            {
                $request["apoio"] = strip_tags($request->apoio, '<a>');
            }

            if($request->fonte == null)
            {
            //    $request->fonte = '';
            }
            else
            {
                $request["fonte"] = strip_tags($request->fonte, '<a>');
            }

            if($request->autores == null)
            {
            //    $request->autores = '';
            }
            else
            {
                $request["autores"] = strip_tags($request->autores, '<a>');
            }

            switch ($request->tipo)
            {
                case 1:
                    $conteudo = $request->conteudo;
                    break;

                case 2:
                    if(isset($request->arquivoAudio))
                        $request->arquivo = $request->arquivoAudio;
                    else
                        $request->conteudo = $request->conteudoAudio;
                    break;
                case 3:
                    if(isset($request->arquivoVideo))
                        $request->arquivo = $request->arquivoVideo;
                    else
                        $request->conteudo = $request->conteudoVideo;
                    break;
                case 4:
                    if(isset($request->arquivoSlide))
                        $request->arquivo = $request->arquivoSlide;
                    else
                        $request->conteudo = $request->conteudoSlide;
                    break;
                    break;
                case 5:
                    $conteudo = $request->conteudoTransmissao;
                    break;
                case 6:
                    if(isset($request->arquivoArquivo))
                        $request->arquivo = $request->arquivoArquivo;
                    else
                        $request->conteudo = $request->conteudoArquivo;
                    break;
                case 7:
                    if($request->conteudoDissertativaDica == null)
                        $request->conteudoDissertativaDica = '';
                    if($request->conteudoDissertativaExplicacao == null)
                        $request->conteudoDissertativaExplicacao = '';

                    $conteudo = json_encode(['pergunta' => $request->conteudoDissertativa, 'dica' => $request->conteudoDissertativaDica, 'explicacao' => $request->conteudoDissertativaExplicacao]);
                    break;
                case 8:
                    $conteudo = json_encode(['pergunta' => $request->conteudoQuiz, 'alternativas' => [ $request->conteudoQuizAlternativa1, $request->conteudoQuizAlternativa2, $request->conteudoQuizAlternativa3 ], 'correta' => $request->conteudoQuizAlternativaCorreta, 'dica' => $request->conteudoQuizDica, 'explicacao' => $request->conteudoQuizExplicacao]);
                    break;
                case 9:
                    $conteudo = $request->conteudoProva;
                    break;
                case 10:
                    $conteudo = $request->conteudoEntregavel;
                    break;
                case 11:
                    if(isset($request->arquivoApostila))
                        $request->arquivo = $request->arquivoApostila;
                    else
                        $request->conteudo = $request->conteudoApostila;
                    break;

                default:
                    $conteudo = $request->conteudo;
                    break;
            }

            if($request->tipo == 2 || $request->tipo == 3 || $request->tipo == 4 || $request->tipo == 6)
            {
                if(isset($request->arquivo))
                {
                    $originalName = mb_strtolower( $request->arquivo->getClientOriginalName(), 'utf-8' );

                    $fileExtension = \File::extension($request->arquivo->getClientOriginalName());
                    $newFileNameArquivo =  md5( $request->arquivo->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

                    $pathArquivo = $request->arquivo->storeAs('uploads/cursos/' . $idCurso . '/arquivos', $newFileNameArquivo, 'local');

                    if(!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo)))
                    // if(!\Storage::disk('gcs')->put($pathArquivo, file_get_contents($request->arquivo)))
                    // if(!\Storage::disk('gcs')->put('uploads/cursos/' . $idCurso . '/arquivos/' . $newFileNameArquivo, file_get_contents($request->arquivo)))
                    {
                        \Session::flash('error', 'Não foi possível fazer upload de seu conteúdo!');
                    }
                    else
                    {
                        $conteudo = $newFileNameArquivo;
                    }
                }
                else
                {
                    $conteudo = $request->conteudo;
                }
            }
            else if($request->tipo == 11)
            {
                $conteudo = "index.html";
            }

            $novo_conteudo = Conteudo::create([
                'titulo' => $request->titulo,
                'descricao' => $request->descricao,
                'tipo' => $request->tipo,
                'conteudo' => $conteudo,
                'tempo' => $request->tempo,
                'apoio' => $request->apoio,
                'fonte' => $request->fonte,
                'autores' => $request->autores,
                'status' => $request->status,
            ]);

            if($request->tipo == 11)
            {
                $zipperFile = \Zipper::make($request->arquivo);

                $logFiles = $zipperFile->listFiles();

                // dd($logFiles);

                if(in_array("index.html", $logFiles) == false || in_array("index.js", $logFiles) == false)
                {
                    $novo_conteudo->delete();

                    return redirect()->back()->withErrors("Conteúdo do zip inválido, por favor consulte as instruções de upload de apostilas!");
                }

                $zipperFile->extractTo(public_path('uploads') . '/apostilas/' . $novo_conteudo->id . '/');

                if (!\Storage::disk('public_uploads')->has('apostilas/' . $novo_conteudo->id))
                {
                    $novo_conteudo->delete();

                    return redirect()->back()->withErrors("Não foi possível extrair o conteúdo do zip, por favor envie sua aplicação novamente!");
                }
            }

            ConteudoAula::create([
                'ordem' => ConteudoAula::where([['aula_id', '=', $request->idAula], ['curso_id', '=', $idCurso]])->max('ordem') + 1,
                'curso_id' => $idCurso,
                'aula_id' => $request->idAula,
                'conteudo_id' => $novo_conteudo->id,
                'user_id' => \Auth::user()->id,
                'obrigatorio' => $request->obrigatorio,
            ]);

            return Redirect::route('gestao.curso-conteudo', ['idCurso' => $idCurso, 'aula' => $request->idAula])->with('message', 'Conteúdo criado com sucesso!');
            // return Redirect::back()->with('message', 'Conteúdo criado com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Aula não encontrada!']);
        }
    }

    public function editarConteudoCurso($idCurso, $idAula, $idConteudo)
    {
        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            if(Conteudo::with('conteudo_aula')
            ->whereHas('conteudo_aula', function ($query) use ($idCurso, $idAula) {
                $query->where([['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]]);
            })->where([['id', '=', $idConteudo]])->first() != null)
            {
                $conteudo = Conteudo::with('conteudo_aula')
                ->whereHas('conteudo_aula', function ($query) use ($idCurso, $idAula) {
                    $query->where([['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]]);
                })->where([['id', '=', $idConteudo]])->first();

                if($conteudo->tipo == 2 || $conteudo->tipo == 3 || $conteudo->tipo == 4 || $conteudo->tipo == 6)
                {
                    // if(\Storage::disk('gcs')->has('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo))
                    // {
                    //     $conteudo->temArquivo = true;
                    // }
                    // else
                    if(\Storage::disk('local')->has('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo))
                    {
                        $conteudo->temArquivo = true;
                    }
                    else
                    {
                        $conteudo->temArquivo = false;
                    }
                }

                return response()->json(['success'=> 'Conteudo encontrado..', 'conteudo' => json_encode($conteudo)]);
            }
            else
            {
                return response()->json(['error' => 'Conteúdo não encontrado!']);
            }
        }
        else
        {
            return response()->json(['error' => 'Aula não encontrada!']);
        }
    }

    public function postSalvarConteudoCurso($idCurso, Request $request)
    {
        // dd($request);

        if(Aula::where([['id', '=', $request->idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            if(Conteudo::where([['id', '=', $request->idConteudo]])->first() != null)
            {
                $conteudoOriginal = Conteudo::where([['id', '=', $request->idConteudo]])->first();

                if($request->descricao == null)
                {
                    $request->descricao = '';
                }

                if($request->obrigatorio == null)
                {
                    $request->obrigatorio = 0;
                }
                elseif($request->obrigatorio == 'on')
                {
                    $request->obrigatorio = 1;
                }

                if($request->tempo == null)
                {
                    $request->tempo = 0;
                }

                // if($request->apoio == null)
                // {
                //     $request->apoio = '';
                // }

                // if($request->fonte == null)
                // {
                //     $request->fonte = '';
                // }

                // if($request->autores == null)
                // {
                //     $request->autores = '';
                // }

                switch ($request->tipo)
                {
                    case 1:
                        $conteudo = $request->conteudo;
                        break;

                    case 2:
                        if(isset($request->arquivoAudio))
                            $request->arquivo = $request->arquivoAudio;
                        else
                            $request->conteudo = $request->conteudoAudio;
                        break;
                    case 3:
                        if(isset($request->arquivoVideo))
                            $request->arquivo = $request->arquivoVideo;
                        else
                            $request->conteudo = $request->conteudoVideo;
                        break;
                    case 4:
                        if(isset($request->arquivoSlide))
                            $request->arquivo = $request->arquivoSlide;
                        else
                            $request->conteudo = $request->conteudoSlide;
                        break;
                        break;
                    case 5:
                        $conteudo = $request->conteudoTransmissao;
                        break;
                    case 6:
                        if(isset($request->arquivoArquivo))
                            $request->arquivo = $request->arquivoArquivo;
                        else
                            $request->conteudo = $request->conteudoArquivo;
                        break;
                    case 7:
                        if($request->conteudoDissertativaDica == null)
                            $request->conteudoDissertativaDica = '';
                        if($request->conteudoDissertativaExplicacao == null)
                            $request->conteudoDissertativaExplicacao = '';

                        $conteudo = json_encode(['pergunta' => $request->conteudoDissertativa, 'dica' => $request->conteudoDissertativaDica, 'explicacao' => $request->conteudoDissertativaExplicacao]);
                        break;
                    case 8:
                        $conteudo = json_encode(['pergunta' => $request->conteudoQuiz, 'alternativas' => [ $request->conteudoQuizAlternativa1, $request->conteudoQuizAlternativa2, $request->conteudoQuizAlternativa3 ], 'correta' => $request->conteudoQuizAlternativaCorreta, 'dica' => $request->conteudoQuizDica, 'explicacao' => $request->conteudoQuizExplicacao]);
                        break;
                    case 9:
                        $conteudo = $request->conteudoProva;
                        break;
                    case 10:
                        $conteudo = $request->conteudoEntregavel;
                        break;
                    case 11:
                        if(isset($request->arquivoApostila))
                            $request->arquivo = $request->arquivoApostila;
                        else
                            $request->conteudo = $request->conteudoApostila;
                        break;

                    default:
                        $conteudo = $request->conteudo;
                        break;
                }

                if($request->tipo == 2 || $request->tipo == 3 || $request->tipo == 4 || $request->tipo == 6)
                {
                    if(isset($request->arquivo))
                    {
                        if($conteudoOriginal->conteudo != null)
                        {
                            if(\Storage::disk('local')->has('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudoOriginal->conteudo))
                            {
                                \Storage::disk('local')->delete('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudoOriginal->conteudo);
                            }
                        }

                        $originalName = mb_strtolower( $request->arquivo->getClientOriginalName(), 'utf-8' );

                        $fileExtension = \File::extension($request->arquivo->getClientOriginalName());
                        $newFileNameArquivo =  md5( $request->arquivo->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

                        $pathArquivo = $request->arquivo->storeAs('uploads/cursos/' . $idCurso . '/arquivos', $newFileNameArquivo, 'local');

                        if(!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo)))
                        // if(!\Storage::disk('gcs')->put($pathArquivo, file_get_contents($request->arquivo)))
                        // if(!\Storage::disk('gcs')->put('uploads/cursos/' . $idCurso . '/arquivos/' . $newFileNameArquivo, file_get_contents($request->arquivo)))
                        {
                            \Session::flash('error', 'Não foi possível fazer upload de seu conteúdo!');
                        }
                        else
                        {
                            $conteudo = $newFileNameArquivo;
                        }
                    }
                    else
                    {
                        if($request->conteudo != "" && $request->conteudo != null)
                            $conteudo = $request->conteudo;
                        else
                            $conteudo = $conteudoOriginal->conteudo;
                    }
                }
                else if($request->tipo == 11)
                {
                    $conteudo = "index.html";
                }

                $conteudoOriginal->update([
                    'titulo' => $request->titulo,
                    'descricao' => $request->descricao,
                    'conteudo' => $conteudo,
                    'obrigatorio' => $request->obrigatorio,
                    'tempo' => $request->tempo,
                    'apoio' => $request->apoio,
                    'fonte' => $request->fonte,
                    'autores' => $request->autores,
                ]);

                if($request->tipo == 11)
                {
                    $tem_arquivo = isset($request->arquivoApostila) || isset($request->conteudoApostila);

                    $tem_conteudo = isset($request->conteudoApostila) ? ($request->conteudoApostila != null && $request->conteudoApostila != '') : false;

                    if($tem_arquivo && $tem_conteudo)
                    {
                        $zipperFile = \Zipper::make($request->arquivo);

                        $logFiles = $zipperFile->listFiles();

                        // dd($logFiles);

                        if(in_array("index.html", $logFiles) == false || in_array("index.js", $logFiles) == false)
                        {
                            $novo_conteudo->delete();

                            return redirect()->back()->withErrors("Conteúdo do zip inválido, por favor consulte as instruções de upload de apostilas!");
                        }

                        $zipperFile->extractTo(public_path('uploads') . '/apostilas/' . $novo_conteudo->id . '/');

                        if (!\Storage::disk('public_uploads')->has('apostilas/' . $novo_conteudo->id))
                        {
                            $novo_conteudo->delete();

                            return redirect()->back()->withErrors("Não foi possível extrair o conteúdo do zip, por favor envie sua aplicação novamente!");
                        }
                    }
                }

                return Redirect::route('gestao.curso-conteudo', ['idCurso' => $idCurso, 'aula' => $request->idAula])->with('message', 'Conteúdo atualizado com sucesso!');
            }
            else
            {
                return response()->json(['error' => 'Conteúdo não encontrado!']);
            }
        }
        else
        {
            return response()->json(['error' => 'Aula não encontrada!']);
        }

        return Redirect::back()->with('message', 'Aula atualizada com sucesso!');
    }

    public function reordenarConteudo($idCurso, $idAula, $idConteudo, $index)
    {
        if(Conteudo::where([['id', '=', $idConteudo], ['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]])->first() != null)
        {
            $ordemAtual = Conteudo::where([['id', '=', $idConteudo], ['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]])->first()->ordem;

            if(Conteudo::where([['ordem', '=', $index], ['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]])->first() != null)
            {
                Conteudo::where([['ordem', '=', $index], ['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]])->update([
                    'ordem' => $ordemAtual,
                ]);
            }

            Conteudo::where([['id', '=', $idConteudo], ['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]])->update([
                'ordem' => $index
            ]);

            return response()->json(['success'=> 'Conteudo reordenado com sucesso!' . $idAula . '-' . $index]);
        }
        else
        {
            return response()->json(['error' => 'Conteudo não encontrado!']);
        }
    }

    public function postDuplicarConteudoCurso($idCurso, Request $request)
    {
        $exists_conteudo = Conteudo::where([['id', '=', $request->idConteudo]])->exists();

        $exists_conteudo_aula = ConteudoAula::where([['conteudo_id', '=', $request->idConteudo], ['curso_id', '=', $idCurso], ['aula_id', '=', $request->idAula]])->exists();

        if($exists_conteudo && $exists_conteudo_aula)
        {
            $new_conteudo = Conteudo::where([['id', '=', $request->idConteudo]])->first()->replicate();

            $new_conteudo->save();

            $new_conteudo_aula = ConteudoAula::where([['conteudo_id', '=', $request->idConteudo], ['curso_id', '=', $idCurso], ['aula_id', '=', $request->idAula]])->first()->replicate();

            $new_conteudo_aula->conteudo_id = $new_conteudo->id;

            // $newConteudo->id = Conteudo::where([['aula_id', '=', $request->idAula], ['curso_id', '=', $idCurso]])->max('id') + 1;

            //Duplicar arquivo do conteudo se aplicavel
            // if($request->tipo == 2 || $request->tipo == 3 || $request->tipo == 4 || $request->tipo == 6)
            // {
            //     $file = \Storage::disk('local')->get('uploads/cursos/' . $idCurso . '/arquivos/' . $newConteudo->conteudo);

            //     $originalName = mb_strtolower( $file->getClientOriginalName(), 'utf-8' );

            //     $fileExtension = \File::extension($file->getClientOriginalName());
            //     $newFileNameArquivo =  md5( $file->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

            //     $pathArquivo = $file->copy('uploads/cursos/' . $idCurso . '/arquivos', $newFileNameArquivo, 'local');

            //     if(!\Storage::disk('local')->copy($pathArquivo, file_get_contents($request->arquivo)))
            //     {
            //         \Session::flash('error', 'Não foi possível duplicar seu conteúdo!');
            //     }
            //     else
            //     {
            //         $conteudo = $newFileNameArquivo;
            //     }
            // }

            $new_conteudo_aula->save();

            \Session::flash('message', 'Conteúdo duplicado com sucesso!');
            return redirect()->route('gestao.curso-conteudo', ['idCurso' => $idCurso, 'aula' => $request->idAula]);

            // return Redirect::back()->with('message', 'Conteúdo duplicado com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Conteúdo não encontrado!']);
        }
    }

    public function postExcluirConteudoCurso($idCurso, Request $request)
    {
        if(ConteudoAula::where([['conteudo_id', '=', $request->idConteudo], ['curso_id', '=', $idCurso], ['aula_id', '=', $request->idAula]])->first() != null)
        {
            $conteudo = ConteudoAula::where([['conteudo_id', '=', $request->idConteudo], ['curso_id', '=', $idCurso], ['aula_id', '=', $request->idAula]])->first();

            // if($conteudo->tipo == 2 || $conteudo->tipo == 3 || $conteudo->tipo == 4 || $conteudo->tipo == 6)
            // {
            //     if($conteudo->conteudo != null)
            //     {
            //         if(\Storage::disk('local')->has('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo))
            //         {
            //             \Storage::disk('local')->delete('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo);
            //         }
            //     }
            // }

            ConteudoAula::where([['conteudo_id', '=', $request->idConteudo], ['curso_id', '=', $idCurso], ['aula_id', '=', $request->idAula]])->delete();

            \Session::flash('success', 'Conteúdo excluido com sucesso!');

            return redirect()->route('gestao.curso-conteudo', ['idCurso' => $idCurso, 'aula' => $request->idAula]);

            // return Redirect::back()->with('message', 'Conteúdo excluido com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Conteúdo não encontrado!']);
        }
    }



    public function rankingProfessores()
    {
        $userLogged = Auth::user(); //PEGA USUARIO LOGADO

        /* RANKING GERAL */
        $professoresGeral = DB::table('users')
            ->leftJoin('avaliacoes_instrutor', 'users.id', '=', 'avaliacoes_instrutor.instrutor_id')
            ->select(DB::raw('users.id as id, users.name as nome, sum(avaliacoes_instrutor.avaliacao) as pontos'))
            ->where('users.permissao', '=', 'P')
            ->groupBy('instrutor_id')
            ->orderBy('pontos', 'DESC')
            ->get();

        $professorIndexGet = $professoresGeral->search(function ($user) {
            return $user->id === Auth::id();
        });

        $professorIndex = ($professorIndexGet !== false) ? $professorIndexGet + 1 : $professorIndexGet;
        /* */

        /* RANKING DE ESCOLAS */
        $escolas = DB::table('escolas')
            ->leftJoin('avaliacoes_escola', 'escolas.id', '=', 'avaliacoes_escola.escola_id')
            ->select(DB::raw('escolas.id as id, escolas.titulo as titulo, sum(avaliacoes_escola.avaliacao) as pontos'))
            ->groupBy('escola_id')
            ->orderBy('pontos', 'DESC')
            ->get();

        $escolaUserIndexGet = $escolas->search(function ($escola) {
            return $escola->id === Auth::user()->escola_id;
        });

        $escolaIndex = ($escolaUserIndexGet !== false) ? $escolaUserIndexGet + 1 : $escolaUserIndexGet;
        /* */

        return view('gestao.ranking-professores', compact('userLogged', 'professoresGeral', 'professorIndex', 'escolas', 'escolaIndex'));
    }

}
<file_sep>/routes/api.php
<?php

use Illuminate\Http\Request;

Route::middleware('auth:api')->get('/user', function (Request $request) {
  return $request->user();
});

Route::group(["prefix" => "v2", "namespace" => "API"], function () {
  Route::post('/login', 'LoginController@login');
  Route::post('/forgot-password', 'LoginController@forgotPassword');
  Route::get('/refresh', 'LoginController@refresh');
  Route::get('/logout', 'LoginController@logout');

  Route::group(["middleware" => "jwt.auth"], function () {
    Route::resource('playlists', 'PlaylistController')->except(['create', 'edit']);
    Route::delete('playlists/{idPlaylist}/audio/{idAudio}', 'AudioPlaylistController@destroy');
    Route::put('playlists/{idPlaylist}/audio/{idAudio}', 'AudioPlaylistController@update');
    Route::post('playlists/{idPlaylist}/audio/{idAudio}', 'AudioPlaylistController@store');

    Route::get('/glossary/{letter?}', 'GlossaryController@show')->name('glossary');

    Route::get('panel', 'PanelController@index')->name('panel');

    Route::resource('users', 'UserController')->except(['create', 'edit']);

    Route::resource('planoaula', 'PlanoAulaController')->only('show');

    Route::resource('cursos', 'CursoController')->only('show');

  });

});

/*

// Badges
Route::prefix('badges')->group(function () {

// http://localhost:8000/api/jpiaget/badges/usuario/1/19/desbloquear
Route::get('usuario/{idUsuario}/{idBadge}/desbloquear', 'Badges\Api\BadgesController@desbloquearUsuarioBadge');

// http://localhost:8000/api/jpiaget/badges/19/desbloquear
Route::get('{idBadge}/desbloquear', 'Badges\Api\BadgesController@desbloquearUsuarioAuthBadge');

});

// Métricas
Route::prefix('metricas')->group(function () {

// http://localhost:8000/api/jpiaget/metricas/nova
Route::post('nova', 'Metricas\Api\MetricasController@nova');

});

// Habilidades
Route::prefix('habilidades')->group(function () {

// http://localhost:8000/api/jpiaget/habilidades/usuario/1/2
Route::post('usuario/{idUsuario}/{idHabilidade}', 'Habilidades\Api\HabilidadesController@UsuarioHabilidade');

// http://localhost:8000/api/jpiaget/habilidades/2
Route::post('{idHabilidade}', 'Habilidades\Api\HabilidadesController@UsuarioAuthHabilidade');
});

// Gamificação
Route::prefix('gamificacao')->group(function () {
Route::post('usuario/{idUsuario}/incrementar', 'GamificacaoUsuario\Api\GamificacaoUsuarioController@incrementar')->name('gamificacao.incrementar');
});

 */
<file_sep>/app/Http/Controllers/Historico/Alunos/HistoricoController.php
<?php

namespace App\Http\Controllers\Historico\Alunos;

use App\Entities\Historico\Historico;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class HistoricoController extends Controller
{
    public function index()
    {
        $historicos = Historico::where('user_id', Auth::user()->id)->groupBy('user_id', 'created_at', 'referencia_id')->get();
        return view('pages.historico.alunos.index', compact('historicos'));
    }


    public function search(Request $request)
    {
        $historicos = Historico::where('user_id', Auth::user()->id)
            ->with('conteudo')
            ->whereHas('conteudo', function ($query) use ($request) {
                $query->where('titulo', 'LIKE', '%' . $request->get('search') . '%');
            })
            ->orWhere('created_at', 'LIKE', '%' . $request->get('search') . '%')
            ->groupBy('user_id', 'created_at', 'referencia_id')
            ->get();
        return view('pages.historico.alunos.index', compact('historicos'));
    }
}
<file_sep>/app/Http/Controllers/HubController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Escola;
use App\Categoria;

use App\Aplicacao;
use App\Conteudo;
use App\AvaliacaoInstrutor;
use App\Matricula;
use App\Metrica;

class HubController extends Controller
{
    public function index()
    {
        if(Input::get('qt') == null)
            $amount = 9;
        else
            $amount = Input::get('qt');

        if(Input::get('ordem') == null)
            $ordem = "alfabetica"; //"recentes"
        else
            $ordem = Input::get('ordem');

        if(Input::get('categoria') == null)
            $categoria = "";
        elseif(Input::get('categoria') == "geral")
            $categoria = "";
        else
            $categoria = Input::get('categoria');

        if($categoria != null)
        {
            if(Categoria::where('titulo', '=', $categoria)->first() != null)
            {
                $categoria = Categoria::where('titulo', '=', $categoria)->first()->id;
            }
        }

        if(Input::get('pesquisa') == null || Input::get('pesquisa') == "")
        {
            $pesquisa = null;

            if($categoria != null)
            {
                $aplicacoes = Aplicacao::with('categoria')->take($amount)->where(function ($query) {
                $query->where('data_lancamento', '=', null)->orWhere('data_lancamento', '<=', date('Y-m-d H:i:s'));
            })->where([['status', '=', '1'], ['categoria_id', '=', $categoria]]);

                $aplicacoes = $aplicacoes->orWhere([['status', '=', '1'], ['tags', 'like', '%' . Categoria::find($categoria)->titulo . '%']]);
            }
            elseif(Input::get('marcador') != null && Input::get('marcador') != "")
            {
                $aplicacoes = Aplicacao::with('categoria')->take($amount)->where(function ($query) {
                $query->where('data_lancamento', '=', null)->orWhere('data_lancamento', '<=', date('Y-m-d H:i:s'));
            })->where([['status', '=', '1'], ['categoria_id', '=', $categoria]]);

                $aplicacoes = $aplicacoes->orWhere([['status', '=', '1'], ['tags', 'like', '%' . Input::get('marcador') . '%']]);
            }
            else
            {
                $aplicacoes = Aplicacao::with('categoria')->take($amount)->where(function ($query) {
                $query->where('data_lancamento', '=', null)->orWhere('data_lancamento', '<=', date('Y-m-d H:i:s'));
            })->where([['status', '=', '1']]);
            }
        }
        else
        {
            $aplicacoes = Aplicacao::with('categoria')->take($amount)->where([['status', '=', '1'], ['titulo', 'like', '%' . Input::get('pesquisa') . '%']])
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        }

        // $aplicacoes = $aplicacoes->orderBy('data_publicacao', 'desc');

        if($ordem == 'recentes')
        {
            $aplicacoes = $aplicacoes->orderBy('created_at', 'desc');
            $ordem = "Mais recentes";
        }
        elseif($ordem == 'antigos')
        {
            $aplicacoes = $aplicacoes->orderBy('created_at', 'asc');
            $ordem = "Mais antigos";
        }
        elseif($ordem == 'alfabetica')
        {
            $aplicacoes = $aplicacoes->orderBy('titulo', 'asc');
            $ordem = "Ordem Alfabética";
        }

        $destaques = $aplicacoes;

        $aplicacoes = $aplicacoes->paginate($amount);

        $destaques = $destaques->where('destaque', '=', 1)->take(5)->get();

        // Preencher destaques se menos que o minimo para o carrousel
        // if(count($destaques) < 5)
        // {
        //     $maisDestaques = $aplicacoes->take(5 - count($destaques));
        //     $destaques = $destaques->merge($maisDestaques);
        // }

        $categorias = Categoria::where([['tipo', '=', 3]])->take(12)->orderBy('titulo', 'asc')->get();

        $marcadores = [];

        foreach ($aplicacoes as $aplicacao)
        {
            if($aplicacao->capa == "")
            {
                $aplicacao->capa = str_replace(".swf", ".png", $aplicacao->arquivo);
                // $aplicacao->capa = 'image' . $aplicacao->id . '.png';
            }
        }

        foreach (Aplicacao::groupBy('tags')->pluck('tags') as $tags)
        {
            if($tags != null)
            {
                foreach ($tags as $tag)
                {
                    if(!in_array($tag, $marcadores) && !$categorias->contains('titulo', $tag))
                    {
                        array_push($marcadores, $tag);
                    }
                }
            }
        }

        // dd($marcadores);



        return view('hub.index')->with( compact('aplicacoes', 'pesquisa', 'amount', 'ordem', 'categorias', 'marcadores', 'destaques') );
    }

    public function aplicacao($idAplicacao)
    {
        $aplicacao = Aplicacao::with('categoria')->find($idAplicacao);

        if($aplicacao == null)
        {
            \Session::flash('warning', 'Aplicação não encontrada.');
            return redirect()->route('hub.index');
        }

        if(!\Storage::disk('public_uploads')->has('aplicacoes/' . $aplicacao->id) || ($aplicacao->status == 0 && Auth::user()->permissao != "Z"))
        {
            \Session::flash('warning', 'Aplicação não encontrada.');

            return redirect()->route('hub.index');
        }

        Metrica::create([
            'user_id' => Auth::check() ? Auth::user()->id : 0,
            'titulo' => 'Visualizar aplicação - ' . $aplicacao->id
        ]);

        $relacionados = Aplicacao::where([['id', '!=', $aplicacao->id], ['categoria_id', '=', $aplicacao->categoria_id]])->get();

        return view('hub.aplicacao')->with( compact('aplicacao', 'relacionados') );
    }

    public function playAplicacao($idAplicacao)
    {
        $aplicacao = Aplicacao::find($idAplicacao);

        if($aplicacao == null)
        {
            \Session::flash('warning', 'Aplicação não encontrada.');
            return redirect()->route('hub.index');
        }

        if(!\Storage::disk('public_uploads')->has('aplicacoes/' . $aplicacao->id) || ($aplicacao->status == 0 && Auth::user()->permissao != "Z"))
        {
            \Session::flash('warning', 'Aplicação não encontrada.');

            return redirect()->route('hub.index');
        }

        Metrica::create([
            'user_id' => Auth::check() ? Auth::user()->id : 0,
            'titulo' => 'Jogar aplicação - ' . $aplicacao->id
        ]);

        return view('hub.aplicacao-play')->with( compact('aplicacao') );
    }

    public function ultimaAplicacao()
    {
        if(Metrica::where([['user_id', '=', Auth::user()->id], ['titulo', 'like', 'Jogar aplicação%']])->first() != null)
        {
            $idUltimaAplicacao = str_replace('Jogar aplicação - ', "", Metrica::where([['user_id', '=', Auth::user()->id], ['titulo', 'like', 'Jogar aplicação - %']])->first()->titulo);

            return redirect()->route('aplicacao', ['idAplicacao' => $idUltimaAplicacao]);
        }
        else
        {
            \Session::flash('error', 'Você não acessou nenhum aplicação recentemente.');

            return redirect()->route('hub.index');
        }
    }
}
<file_sep>/app/Http/Controllers/Catalogo/Alunos/CatalogoController.php
<?php

namespace App\Http\Controllers\Catalogo\Alunos;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class CatalogoController extends Controller
{
    public function index()
    {
        return view('pages.catalogo.alunos.index');
    }
}
<file_sep>/app/Http/Controllers/Audio/Admin/AudioController.php
<?php

namespace App\Http\Controllers\Audio\Admin;

use Illuminate\Support\Facades\Input;

use App\Categoria;
use App\Entities\Audio\Audio;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;

class AudioController extends Controller
{
    public function index()
    {
        $audios = Audio::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $audios->when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $audios = $audios
        ->where('user_id', Auth::user()->id)
        ->orderBy('id', 'DESC')
        ->get();

        $categorias = Categoria::where('tipo', 5)->select('id', 'titulo')->get();

        return view('pages.audios.admin.index', compact('categorias', 'audios'));
    }

    public function store(Request $request)
    {
        $mimesTypesValidation = ['audio/mp3', 'audio/wav'];
        $sizeValidation = 5000000;

        $this->validate($request, ['titulo' => 'required', 'categoria_id' => 'required', 'file' => 'required']);

        $file = $request->file('file');
        if (array_search($file->getClientMimeType(), $mimesTypesValidation) === false) {
            return redirect()->route('gestao.audios.listar')->withErrors(['Arquivo não aceito.']);
        }

        if ($file->getClientSize() > $sizeValidation) {
            return redirect()->route('gestao.audios.listar')->withErrors(['Arquivo muito grande!']);
        }

        $fileExtension = \File::extension($request->file->getClientOriginalName());
        $newFileNameAudio = md5($request->file->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

        $pathFile = $request->file->storeAs('audios/user_id_' . Auth::user()->id, $newFileNameAudio, 'public_uploads');

        if (!Storage::disk('public_uploads')->put($pathFile, file_get_contents($request->file))) {
            \Session::flash('middle_popup', 'Ops! Não foi possivel enviar seu áudio.');
            \Session::flash('popup_style', 'danger');
        }

        Audio::create([
            'user_id'      => Auth::user()->id,
            'categoria_id' => $request->get('categoria_id'),
            'titulo'       => $request->get('titulo'),
            'descricao'    => $request->get('descricao'),
            'file'         => $newFileNameAudio,
            'duracao'      => $request->get('duracao')
        ]);

        return redirect()->route('gestao.audios.listar')->with('message', 'Áudio cadastrado com sucesso!');
    }




    public function update(Request $request, $idAudio)
    {
        $mimesTypesValidation = ['audio/mp3', 'audio/wav'];
        $sizeValidation = 5000000;

        $this->validate($request, ['titulo' => 'required']);

        $file = $request->get('audio_atual');

        if ($request->file) {
            if (array_search($request->file->getClientMimeType(), $mimesTypesValidation) === false) {
                return redirect()->route('gestao.audios.listar')->withErrors(['Arquivo não aceito.']);
            }

            if ($request->file->getClientSize() > $sizeValidation) {
                return redirect()->route('gestao.audios.listar')->withErrors(['Arquivo muito grande!']);
            }

            if (Storage::disk('public_uploads')->has('audios/user_id_' . Auth::user()->id . '/' . $file)) {
                Storage::disk('public_uploads')->delete('audios/user_id_' . Auth::user()->id . '/' . $file);
            }

            $fileExtension = \File::extension($request->file->getClientOriginalName());
            $file = md5($request->file->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

            $pathFile = $request->file->storeAs('audios/user_id_' . Auth::user()->id, $file, 'public_uploads');

            if (!Storage::disk('public_uploads')->put($pathFile, file_get_contents($request->file))) {
                \Session::flash('middle_popup', 'Ops! Não foi possivel enviar seu áudio.');
                \Session::flash('popup_style', 'danger');
            }
        }


        $audio = Audio::find($idAudio);

        $r = $audio->update([
            'categoria_id' => $request->get('categoria_id'),
            'titulo'       => $request->get('titulo'),
            'descricao'    => $request->get('descricao'),
            'file'         => $file,
            'duracao'      => $request->get('duracao')
        ]);

        return redirect()->route('gestao.audios.listar')->with('message', 'Áudio atualizado com sucesso!');
    }




    public function destroy($idAudio)
    {
        $audio = Audio::find($idAudio);

        if (!$audio) {
            return redirect()->back()->withErrors(['Áudio não encontrado!']);
        }

        if (Storage::disk('public_uploads')->has('audios/user_id_' . Auth::user()->id . '/' . $audio->file)) {
            Storage::disk('public_uploads')->delete('audios/user_id_' . Auth::user()->id . '/' . $audio->file);
        }

        if ($audio->albuns->toArray() != null) {
            $audio->albuns()->detach();
        }

        if ($audio->playlists->toArray() != null) {
            $audio->playlists()->detach();
        }

        $audio->delete();
        return redirect()->route('gestao.audios.listar')->with('message', 'Áudio excluido com sucesso!');

    }


}
<file_sep>/app/Http/Controllers/API/InstructorController.php
<?php

namespace App\Http\Controllers\API;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use App\User;

class InstructorController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
      try 
      {
        $users = User::where('permissao', 'P')
          ->with(['albuns' => function ($query) {
          $query->select('albums.id', 'albums.titulo', 'albums.capa as url', 'albums.descricao', 
            'albums.categoria', 'albums.user_id as artist', 'albums.user_id', 'albums.created_at');
        }])->select('users.id', 'users.name', 'users.email', 'users.img_perfil', 'users.descricao')
        ->get();

        return response()->json(["data" => $users]);
      }
      catch (\Exception $exception) 
      {
        return response()->json(['error' => true, 'message:' => $exception->getMessage()], 500);
      }
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        //
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
      try {
        $user = User::where('id', $id)->where('permissao', 'P')
            ->with(['albuns' => function ($query) {
                $query->select('albums.id', 'albums.titulo', 'albums.capa as url', 'albums.descricao',
                    'albums.categoria', 'albums.user_id as artist', 'albums.user_id', 'albums.created_at');
            }])
            ->select('users.id', 'users.name', 'users.email', 'users.img_perfil', 'users.descricao')
            ->first();
        if (!empty($user)) {
          return response()->json(["data" => $user]);
        } else {
          return response()->json(["error" => true, "message" => "Erro ao encontrar instrutor"], 404);
        }
      } catch (\Exception $exception) {
          return response()->json(['error' => true, 'message:' => $exception->getMessage()], 500);
      }
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
        //
    }
}
<file_sep>/app/ProgressoConteudo.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class ProgressoConteudo extends Model
{
    protected $table = 'progresso_conteudo';

    //Preenchiveis
    protected $fillable = [
        'conteudo_id',
        'user_id',
        'tipo',
        'progresso',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'tipo' => 1,
        'progresso' => 0
    ];

    // Tipos de conteudo
    // 1 = Aplicação ( Jogos )
    // 2 = Conteudo ( Vídeos, documentos, slides etc)

    public function aplicacao()
    {
        return $this->belongsTo('App\Aplicacao', 'conteudo_id');
    }

    public function conteudo()
    {
        return $this->belongsTo('App\Conteudo', 'conteudo_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/Http/Controllers/Badges/Admin/BadgesController.php
<?php

namespace App\Http\Controllers\Badges\Admin;

use App\Entities\Badges\Repository as Badge;
use App\Entities\Users\Repository as User;
use App\Generals\Upload\Upload;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;


class BadgesController extends Controller
{

    private $badge;
    private $user;
    private $upload;

    public function __construct(Badge $badge, User $user, Upload $upload)
    {
        $this->badge = $badge;
        $this->user = $user;
        $this->upload = $upload;
    }

    // listar todas as badges
    public function index()
    {
        $badges = $this->badge->all();
        $alunos = $this->user->getAll('A');
        return view('pages.badges.admin.index', compact('badges', 'alunos'));
    }


    // Gravar uma nova badge
    public function store(Request $request)
    {
        // Faz a validação do campo título como obrigatório.
        $this->validate($request, [
            'titulo' => 'required'
        ]);

        // recupera os valores dos inputs
        $values = $request->all();

        // recupera id do usuário logado que está cadastrando a badge
        $values['user_id'] = Auth::user()->id;

        // verifica se a pessoa fez o envio de um ícone para a badge
        if ($request->file('icone')) {
            $file = $request->file('icone');
            $fileName = $this->upload->makeResize($file, 400, 'badges/capas');
            $values['icone'] = $fileName;
            if ($fileName == false) {
                return \Session::flash('error', 'Não foi possível fazer upload de seu conteúdo!');
            }
        }

        $this->badge->store($values);
        return redirect()->route('gestao.badges.listar')->with('message', 'Badge cadastrada com sucesso!');
    }


    public function update($idBadge, Request $request)
    {
        // Faz a validação do campo título como obrigatório.
        $this->validate($request, [
            'titulo' => 'required'
        ]);
        $this->badge->update($idBadge, $request->all());
        return redirect()->route('gestao.badges.listar')->with('message', 'Badge atualizada com sucesso!');
    }


    // Atualiza o ícone de uma badge
    public function updateIconBadge($idBadge, Request $request)
    {
        // Verifica se já existe um ícone para esta badge, se exitir, deleta a imagem antiga antes de realizar o novo upload
        if ($request->get('oldIcon') !== null) {
            Storage::disk('public_uploads')->delete('badges/capas/' . $request->get('oldIcon'));
        }
        $file = $request->file('icone');
        $fileName = $this->upload->makeResize($file, 400, 'badges/capas');
        if ($fileName == false) {
            return \Session::flash('error', 'Não foi possível fazer upload de seu conteúdo!');
        }
        $this->badge->update($idBadge, ['icone' => $fileName]);
        return redirect()->route('gestao.badges.listar')->with('message', 'Ícone atualizado com sucesso!');
    }


    // Deletar badge selecionada
    public function delete(Request $request)
    {
        // verifica se existe algum ícone relacionada a esta badge
        $badgeIcon = $this->badge->find($request->idBadge)->icone;
        if ($badgeIcon !== null) {
            Storage::disk('public_uploads')->delete('badges/capas/' . $badgeIcon);
        }
        $this->badge->delete($request->idBadge);
        return redirect()->route('gestao.badges.listar')->with('message', 'Badge excluída com sucesso!');
    }

}
<file_sep>/app/Http/Controllers/FinanceiroController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use App\User;
use App\HelperClass;

use App\Transacao;
use App\ProdutoTransacao;

use Auth;

class FinanceiroController extends Controller
{

    public function index()
    {
        if(Input::get('qt') == null)
            $amount = 10;
        else
            $amount = Input::get('qt');

        $transacoes = Transacao::with('user', 'produtos')->orderBy('created_at', 'desc')->get();        
        
        foreach ($transacoes as $transacao)
        {
            switch ($transacao->status)
            {
                case 2:
                $transacao->status_name = "Processando pagamento";
                break;
                case 3:
                $transacao->status_name = "Paga";
                break;
                case 4:
                $transacao->status_name = "Concluída";
                break;
                case 5:
                $transacao->status_name = "Em disputa";
                break;
                case 6:
                $transacao->status_name = "Devolvida";
                break;
                case 7:
                $transacao->status_name = "Cancelada";
                break;
                case 8:
                $transacao->status_name = "Debitado";
                break;
                case 9:
                $transacao->status_name = "Retenção temporária";
                break;
                
                default:
                $transacao->status_name = "Aguardando pagamento";
                break;
            }
        }

        $saldoReceber = Transacao::where('status', '<', 3)->sum('total');
        $saldoDisponivel = Transacao::where('status', '=', 3)->orWhere('status', '=', 4)->sum('total');
        $totalFaturado = Transacao::where('status', '<', 5)->sum('total');

        return view('dashboard.financeiro')->with(compact('amount', 'transacoes', 'saldoReceber', 'saldoDisponivel','totalFaturado'));

    }
}
<file_sep>/app/Http/Controllers/API/PanelController.php
<?php

namespace App\Http\Controllers\API;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Illuminate\Support\Facades\Storage;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Badge;
use App\BadgeUsuario;
use App\Categoria;
use App\Conteudo;
use App\AvaliacaoInstrutor;
use App\Metrica;

use App\Curso;
use App\CursoCompleto;
use App\ConteudoCompleto;
use App\Aula;
use App\ConteudoAula;

use App\Http\Controllers\Controller;
use Tymon\JWTAuth\Exceptions\JWTException;
use Tymon\JWTAuth\Facades\JWTAuth;

class PanelController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
      $user = JWTAuth::toUser();
      $concluidos = CursoCompleto::with('curso')->has('curso')->where([['user_id', '=', $user->id]])->get();

      $ultimos = ConteudoCompleto::with('curso')->has('curso')->where([['user_id', '=', $user->id]])->orderBy('created_at', 'desc')->get();

      $ultimos = $ultimos->unique(function ($item) {
          return $item->curso->id;
      });

      $continuar = null;

      foreach ($ultimos as $key => $ultimo)
      {
          $total_conteudos = Conteudo::whereHas('conteudo_aula', function ($query) use ($ultimo) {
              $query->where([['curso_id', '=', $ultimo->curso->id], ['obrigatorio', '=', '1']]);
          })->count();

          // if(Conteudo::where([['curso_id', '=', $ultimo->curso->id], ['obrigatorio', '=', '1']])->count() > 0)
          if($total_conteudos > 0)
          {
              $ultimo->progresso = number_format((ConteudoCompleto::where([['user_id', '=', $user->id], ['curso_id', '=', $ultimo->curso->id]])->count() * 100) / $total_conteudos, 2);
          }
          else
          {
              $ultimo->progresso = 0;
          }

          if($ultimo->progresso > 100)
              $ultimo->progresso = 100;

          if($ultimo->progresso < 100 && $continuar == null)
          {
              $continuar = $ultimo;
          }
      }

      if($continuar != null)
      {
          $ultimo->qtAulas = Aula::where('curso_id', '=', $ultimo->curso->id)->count();

          foreach (Aula::where('curso_id', '=', $ultimo->curso->id)->orderBy('id', 'asc')->get() as $key => $aula)
          {
              if(ConteudoCompleto::where([['user_id', '=', $user->id], ['curso_id', '=', $ultimo->curso->id], ['aula_id', '=', $aula->id]])->count() >= ConteudoAula::where([['curso_id', '=', $ultimo->curso->id], ['obrigatorio', '=', '1'], ['aula_id', '=', $aula->id]])->count())
              {
                  continue;
              }
              else
              {
                  $ultimo->ultimaAula = ($key + 1);

                  foreach (ConteudoAula::where([['curso_id', '=', $ultimo->curso->id], ['aula_id', '=', $aula->id]])->orderBy('ordem', 'asc')->get() as $key2 => $conteudo)
                  {
                      if(ConteudoCompleto::where([['user_id', '=', $user->id], ['curso_id', '=', $ultimo->curso->id], ['aula_id', '=', $aula->id], ['conteudo_id', '=', $conteudo->id]])->first() != null)
                      {
                          continue;
                      }
                      else
                      {
                          $ultimo->ultimoConteudo = ($key2 + 1);
                          $ultimo->qtConteudos = ConteudoAula::where([['curso_id', '=', $ultimo->curso->id], ['aula_id', '=', $aula->id]])->orderBy('ordem', 'asc')->count();

                          break;
                      }
                  }

                  break;
              }
          }
      }

      return response()->json( array("ultimos" => $ultimos, "continuar" => $continuar, "concluidos" => $concluidos) );
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        //
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        //
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
        //
    }
}
<file_sep>/app/Entities/Playlist/PlaylistAudio.php
<?php

namespace App\Entities\Playlist;

use Illuminate\Database\Eloquent\Model;

class PlaylistAudio extends Model
{
    protected $table = "playlist_audios";

    //Preenchiveis
    protected $fillable = [
        'playlist_id',
        'audio_id'
    ];
}
<file_sep>/app/Http/Controllers/Roteiros/Api/RoteirosApiController.php
<?php
/*
namespace App\Http\Controllers\Roteiros\Api;

use App\Entities\Roteiro\Roteiro;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class RoteiroApiController extends Controller
{
    public function listar($filter = null)
    {
        try {
            if ($filter !== null) {
                return response()->json(Roteiro::where('categoria_id', $filter)->orderBy('id', 'DESC')->get());
            }
            return response()->json(Roteiro::orderBy('id', 'DESC')->get());
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao listar.", "message:" => $exception->getMessage()]);
        }
    }




    public function show($idRoteiro)
    {
        try {
            $Roteiro = Roteiro::find($idRoteiro);
            if (!$Roteiro) {
                return response()->json(['error' => 'Nenhum áudio foi encontrado']);
            }
            return response()->json($Roteiro);
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao encontrar", "message:" => $exception->getMessage()]);
        }
    }

}
<file_sep>/app/Http/Controllers/Roteiros/Admin/RoteirosController.php
<?php

namespace App\Http\Controllers\Roteiros\Admin;

use Illuminate\Support\Facades\Input;

use App\Entities\Roteiros\Roteiros;
use App\Entities\Roteiros\RoteirosTopico;

use Illuminate\Http\Request;

use App\Http\Controllers\Controller;

use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;

class RoteirosController extends Controller
{
    public function index(Request $request)
    {
        $roteiros = Roteiros::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $roteiros->when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $is_admin = strtoupper(Auth::user()->permissao) == "Z";

        $roteiros->when($is_admin == false, function ($query) {
            return $query->where('user_id', '=', Auth::user()->id);
        });

        $roteiros = $roteiros
        ->orderBy('id', 'DESC')
        ->get();

        foreach($roteiros as $r)
        {
            $topicosAtivos = 0;
            $topicosInativos = 0;

            $r->topicos->topicosAtivos = $topicosAtivos;
            $r->topicos->topicosInativos = $topicosInativos;

            foreach($r->topicos as $t)
            {
                if($t->status == 1)
                {
                    $r->topicos->topicosAtivos++;
                }
                else
                {
                    $r->topicos->topicosInativos++;
                }
            }
        }

        return view('pages.roteiros.admin.index', compact('roteiros'));
    }

    public function store(Request $request)
    {
        $roteiro = Roteiros::create([
            'user_id'   => Auth::user()->id,
            'titulo'    => $request->get('titulo'),
        ]);

        $roteiro->save();

        $lastInsertedId = $roteiro->id;

        if($request->get('topico'))
        {
            foreach($request->get('topico') as $t)
            {
                $topicos = RoteirosTopico::create([
                    'titulo' => $t['titulo'],
                    'roteiro_id' => $lastInsertedId,
                    'status' => 0
                ]);
            }
        }

        return redirect('gestao/roteiros')->with('success', 'Roteiro cadastrado com sucesso!');
    }

    public function view(Request $request, $idRoteiro)
    {
        $roteiro = Roteiros::find($idRoteiro);
    }

    public function update(Request $request, $idRoteiro)
    {
        $roteiro = Roteiros::find($idRoteiro);

        // atualiza
        $roteiro->update([
            'titulo'    => $request->get('titulo')
        ]);

        $roteiro->topicos()->delete();
        if($request->get('topico'))
        {
            foreach($request->get('topico') as $t)
            {
                $tituloRoteiro = $t['titulo'];

                $statusTopico = isset($t['status']) ? ($t['status'] == 1 ? 1 : 0) : 0;

                $topicos = RoteirosTopico::create([
                    'titulo' => $tituloRoteiro,
                    'roteiro_id' => $idRoteiro,
                    'status' => $statusTopico
                ]);
            }
        }

        return redirect('gestao/roteiros')->with('message', 'Roteiro atualizado com sucesso!');
    }

    public function ajaxUpdateStatusTopico(Request $request)
    {
        $idTopico = $request->post('id');
        $statusTopico = $request->post('status');

        $update = RoteirosTopico::find($idTopico)->update(['status' => $statusTopico]);

        return $statusTopico;
    }


    public function destroy($idRoteiro)
    {
        $roteiro = Roteiros::find($idRoteiro);

        if (!$roteiro) {
            return redirect()->back()->withErrors(['Roteiro não encontrado!']);
        }

        $roteiro->topicos()->delete();
        $roteiro->delete();

        return redirect('gestao/roteiros')->with('message', 'Roteiro excluído com sucesso!');
    }

}
<file_sep>/app/Entities/TesteNivelamento/TesteNivelamentoQuestao.php
<?php

namespace App\Entities\TesteNivelamento;

use App\Entities\Questoes\Questoes;
use Illuminate\Database\Eloquent\Model;

class TesteNivelamentoQuestao extends Model
{
    protected $table = "teste_nivelamento_questao";
    
    //Preenchiveis
    protected $fillable = [
        'teste_id',
        'questao_id',
        'peso'
    ];
    
    public function questao()
    {
        return $this->belongsTo(Questoes::class, 'questao_id');
    }
}
<file_sep>/app/Entities/HabilidadeUsuario/Repository.php
<?php

namespace App\Entities\HabilidadeUsuario;


use App\Entities\HabilidadeUsuario\HabilidadeUsuario;
use Illuminate\Support\Facades\Auth;

class Repository
{
    private $habilidadeusuario;

    public function __construct(HabilidadeUsuario $habilidadeUsuario)
    {
        $this->habilidadeusuario = $habilidadeUsuario;
    }

    public function all()
    {
        return $this->habilidadeusuario->with('habilidade')->where('user_id', Auth::user()->id)->get();
    }

}
<file_sep>/docker/app/Dockerfile
FROM php:7.2-fpm-alpine

LABEL maintainer "Edulabzz"

RUN echo "http://dl-cdn.alpinelinux.org/alpine/edge/community" >> /etc/apk/repositories

RUN apk update && apk --no-cache add \
   build-base \
   git \
   shadow \
   icu-dev \
   libzip-dev \
   freetype \
   libpng \
   libjpeg-turbo \
   freetype-dev \
   libpng-dev \
   libjpeg-turbo-dev \
   zip \
   nodejs \
   npm \
   g++
RUN docker-php-ext-configure gd \
   --with-gd \
   --with-freetype-dir=/usr/include/ \
   --with-png-dir=/usr/include/ \
   --with-jpeg-dir=/usr/include/
RUN docker-php-ext-install \
   pdo_mysql \
   mysqli \
   zip \
   intl \
   gd

# Copy composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Copy application files (Files are changed between builds so docker cache won't be used for subsequent layers)
COPY . /opt/jpiaget
WORKDIR /opt/jpiaget

EXPOSE 80

CMD /opt/jpiaget/docker/app/start.sh<file_sep>/app/BadgeUsuario.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class BadgeUsuario extends Model
{
    protected $table = 'badge_usuario';

    //Preenchiveis
    protected $fillable = [
        'badge_id',
        'user_id',
    ];

    public function badge()
    {
        return $this->belongsTo('App\Badge', 'badge_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/EnderecoUser.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class EnderecoUser extends Model
{
    protected $table = 'endereco_user';

    protected $primaryKey = 'user_id';

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'cep',
        'uf',
        'cidade',
        'bairro',
        'logradouro',
        'numero',
        'complemento',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'cidade' => '',
        'bairro' => '',
        'logradouro' => '',
    ];

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/Http/Controllers/API/CursoController.php
<?php

namespace App\Http\Controllers\API;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class CursoController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        //
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        if(is_numeric($idCurso))
        {
            if(Curso::find($idCurso) != null)
            {
                $curso = Curso::with('aulas', 'user', 'avaliacoes_user', 'topicos')->where([['id', '=', $idCurso]])->first();
                // $curso = Curso::with('aulas', 'user', 'avaliacoes_user')->where([['escola_id', '=', $escola->id], ['id', '=', $idCurso]])->first();
            }
        }
        else
        {
            // Verificação comentada, apenas usada se o titulo for codificado com traços ao inves de espaços
            // if(Curso::where('titulo', '=', str_replace('-', ' ', $idCurso))->first() != null)
            if(Curso::where('titulo', '=', $idCurso)->first() != null)
            {
                $curso = Curso::with('aulas', 'user', 'avaliacoes_user', 'topicos')->where([['escola_id', '=', $escola->id], ['titulo', '=', $idCurso]])->first();
            }
            elseif(is_numeric( substr(strrchr($idCurso, "-"), 1) ))
            {
                if(Curso::find(substr(strrchr($idCurso, "-"), 1)) != null)
                {
                    $temp = Curso::find(substr(strrchr($idCurso, "-"), 1));

                    $tempTitulo = mb_strtolower($temp->titulo . '-' . $temp->id, 'utf-8');

                    if($tempTitulo == $idCurso)
                    {
                        $curso = Curso::find(substr(strrchr($idCurso, "-"), 1));
                    }
                }
            }
        }

        // dd(count(array_filter(Session::get('carrinho'), function($k) use ($curso) { return ($k->tipo == 2 && $k->id == $curso->id); })));

        if(isset($curso) ? ($curso == null) : (true))
        {
            Session::flash('error', "Curso não encontrado!");

            return redirect()->route('catalogo');
        }

        if($curso->status != 1)
        {
            if(Auth::check() ? (strtolower(Auth::user()->permissao) != "z" && $curso->user_id != Auth::user()->id) : true)
            {
                Session::flash('error', "Curso não encontrado!");

                return redirect()->route('catalogo');
            }
            else
            {
                Session::flash('previewMode', true);
            }
        }

        if($curso->senha != "" && $curso->senha != null)
        {
            if(Session::has('senhaCurso'. $curso->id))
            {
                if(Session::get('senhaCurso'. $curso->id) != $curso->senha)
                {
                    Session::forget('senhaCurso'. $curso->id);
                    return Redirect::back()->withErrors(['Senha do curso inválida!']);
                }
            }
            else
            {
                // if($curso->escola_id != 1)
                // {
                //     // return Redirect::route('curso.trancado', ['escola_id' => $curso->escola_id, 'idCurso' => $curso->id]);
                // }
                // else
                {
                    return Redirect::route('curso.trancado', ['idCurso' => $curso->id]);
                }
            }
        }

        $curso->duracao = 0;

        foreach ($curso->aulas as $key => $aula)
        {
            // $aula->conteudos = Conteudo::where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]])->orderBy('ordem', 'asc')->get();
            $aula->conteudos = Conteudo::
            with('conteudo_aula')
            ->whereHas('conteudo_aula', function ($query) use ($curso, $aula) {
                $query->where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]]);
            })
            // ->orderBy('ordem', 'asc')
            ->get()
            ->sortBy('conteudo_aula.ordem');

            $aula->conteudos = Conteudo::detalhado($aula->conteudos);

            $aula->duracao = Conteudo::
            whereHas('conteudo_aula', function ($query) use ($curso, $aula) {
                $query->where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]]);
            })
            ->sum('duracao');

            if($aula->duracao == 0)
            {
                $aula->duracao = count($aula->conteudos) * 120;
            }


            $curso->duracao += $aula->duracao;

            if($aula->duracao > 60)
            {
                $horas = floor($aula->duracao / 60);
                $minutos = number_format((($aula->duracao / 60) - $horas) * 60, 0);
                $aula->duracao = $horas . ':' . ($minutos < 10 ? '0' . $minutos : $minutos);
            }
            else
            {
                $aula->duracao = '00:' . ($aula->duracao < 10 ? '0' . $aula->duracao : $aula->duracao);
            }
        }

        if($curso->duracao > 60)
        {
            $horas = floor($curso->duracao / 60);
            $minutos = number_format((($curso->duracao / 60) - $horas) * 60, 0);
            $curso->duracao = $horas . ':' . ($minutos < 10 ? '0' . $minutos : $minutos);
        }
        else
        {
            $curso->duracao = '00:' . ($curso->duracao < 10 ? '0' . $curso->duracao : $curso->duracao);
        }

        if(AvaliacaoCurso::where('curso_id', '=', $curso->id)->avg('avaliacao') > 0)
            $curso->avaliacao = AvaliacaoCurso::where('curso_id', '=', $curso->id)->avg('avaliacao');
        else
            $curso->avaliacao = 5;

        if(AvaliacaoInstrutor::where('instrutor_id', '=', $curso->user_id)->avg('avaliacao') > 0)
            $curso->user->avaliacao = AvaliacaoInstrutor::where('instrutor_id', '=', $curso->user_id)->avg('avaliacao');
        else
            $curso->user->avaliacao = 5;

        if(AvaliacaoEscola::where('escola_id', '=', $curso->escola_id)->avg('avaliacao') > 0)
            $curso->avaliacao_escola = AvaliacaoEscola::where('escola_id', '=', $curso->escola_id)->avg('avaliacao');
        else
            $curso->avaliacao_escola = 5;

        Metrica::create([
            'user_id' => Auth::check() ? Auth::user()->id : 0,
            'titulo' => 'Visualização curso - ' . $curso->id
        ]);

        $curso->visualizacoes = Metrica::where('titulo', '=', 'Visualização curso - ' . $curso->id)->count();

        $matricula = Auth::check() ? Matricula::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $curso->id]])->first() : null;

        $curso->transacoes = null;

        $curso->statusPagamento = null;

        if(Auth::check())
        {
            $curso->transacoes = collect();

            foreach (ProdutoTransacao::where([['user_id', '=', Auth::user()->id], ['produto_id', '=', $curso->id]])->get() as $produto)
            {
                if(Transacao::where('referencia_id', $produto->transacao_id)->first() != null)
                {
                    $curso->transacoes->push( Transacao::where('referencia_id', $produto->transacao_id)->first() );
                }
            }

            // dd(ProdutoTransacao::where([['user_id', '=', Auth::user()->id], ['produto_id', '=', $curso->id]])->get());

            $curso->transacoes = $curso->transacoes->unique(function ($item) {
                return $item->id;
            });

            if(count($curso->transacoes) > 0)
            {
                $curso->statusPagamento = $curso->transacoes[0]->status;
            }

            foreach ($curso->transacoes as $transacao)
            {
                if($transacao->status == 3 || $transacao->status == 4)
                {
                    $curso->statusPagamento = $transacao->status;
                    break;
                }
            }
        }

        // dd($curso->avaliacoes_user[0]->user->name);
        // dd($curso);

        // dd($curso->transacoes);
        // dd($curso->topicos);

        return response()->json(["data" => ["curso" => $curso, "matricula" => $matricula]]);
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
        //
    }
}
<file_sep>/database/migrations/2019_08_08_111945_create_teste_nivelamentos_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateTesteNivelamentosTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('teste_nivelamentos', function(Blueprint $table)
		{
			$table->increments('id');
			$table->timestamps();
			$table->text('descricao', 65535)->nullable();
			$table->text('recomendacoes')->nullable();
			$table->float('tempo', 10, 0)->nullable();
			$table->string('titulo');
			$table->integer('user_id');
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('teste_nivelamentos');
	}

}
<file_sep>/app/Http/Controllers/Playlist/Api/PlaylistApiController.php
<?php

namespace App\Http\Controllers\Playlist\Api;

use App\Entities\Playlist\Playlist;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Validator;

class PlaylistApiController extends Controller
{
    public function listar()
    {
        try {
            return response()->json(Playlist::where('user_id', Auth::user()->id)->orderBy('id', 'DESC')
                ->select('playlists.id', 'playlists.user_id', 'playlists.user_id as artist', 'playlists.titulo',
                    'playlists.created_at')
                ->with(['audios' => function ($query) {
                    $query->select('audios.id', 'audios.titulo as title', 'audios.user_id as artist',
                        'audios.file as url', 'audios.descricao', 'audios.duracao as duration');
                }])
                ->get());
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao listar.", "message:" => $exception->getMessage()]);
        }
    }




    public function show($idPlaylist)
    {
        try {
            $playlist = Playlist::where('user_id', Auth::user()->id)
                ->select('playlists.id', 'playlists.user_id', 'playlists.user_id as artist', 'playlists.titulo',
                    'playlists.created_at')
                ->with(['audios' => function ($query) {
                    $query->select('audios.id', 'audios.titulo as title', 'audios.user_id as artist', 'audios.file as url',
                        'audios.descricao', 'audios.duracao as duration');
                }])
                ->find($idPlaylist);
            if (!$playlist) {
                return response()->json(['error' => 'Nenhuma playlist foi encontrada']);
            }
            return response()->json($playlist);
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao encontrar", "message:" => $exception->getMessage()]);
        }
    }




    public function store(Request $request)
    {
        $validate = Validator::make($request->all(), [
            'titulo'   => ['required'],
            'audio_id' => ['required'],
        ], [
            'audio_id.required' => 'Selecione pelo menos 1 áudio em sua playlist.'
        ]);

        if ($validate->fails()) {
            return response()->json(['error' => true, 'errorMessage' => $validate->errors()]);
        }
        try {
            $playlist = Playlist::create([
                'user_id' => Auth::user()->id,
                'titulo'  => $request->get('titulo')
            ]);
            $playlist->audios()->attach($request->get('audio_id'));
            return response()->json('Playlist cadastrada com sucesso!');
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao criar playlist", "message:" => $exception->getMessage()]);
        }
    }




    public function update(Request $request, $idPlaylist)
    {
        $validate = Validator::make($request->all(), ['titulo' => ['required']]);

        if ($validate->fails()) {
            return response()->json(['error' => true, 'errorMessage' => $validate->errors()]);
        }

        try {
            Playlist::where('user_id', Auth::user()->id)->find($idPlaylist)->update(['titulo' => $request->get('titulo')]);
            return response()->json('Playlist atualizada com sucesso!');
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao atualizar playlist", "message:" => $exception->getMessage()]);
        }
    }




    public function updateAudios(Request $request, $idPlaylist)
    {
        $validate = Validator::make($request->all(), [
            'audio_id' => ['required'],
        ], [
            'audio_id.required' => 'Selecione pelo menos 1 áudio em sua playlist.'
        ]);

        if ($validate->fails()) {
            return response()->json(['error' => true, 'errorMessage' => $validate->errors()]);
        }

        try {
            $playlist = Playlist::where('user_id', Auth::user()->id)->find($idPlaylist);
            $playlist->audios()->sync($request->get('audio_id'));
            return response()->json('Playlist atualizada com sucesso!');
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao atualizar playlist", "message:" => $exception->getMessage()]);
        }
    }




    public function removeOneAudio(Request $request, $idPlaylist)
    {
        try {
            $playlist = Playlist::where('user_id', Auth::user()->id)->find($idPlaylist);
            $playlist->audios()->detach($request->get('audio_id'));
            return response()->json('Playlist atualizada com sucesso!');
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao atualizar playlist", "message:" => $exception->getMessage()]);
        }
    }




    public function storeOneAudio(Request $request, $idPlaylist)
    {
        try {
            $playlist = Playlist::where('user_id', Auth::user()->id)->find($idPlaylist);
            $playlist->audios()->attach($request->get('audio_id'));
            return response()->json('Playlist atualizada com sucesso!');
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao atualizar playlist", "message:" => $exception->getMessage()]);
        }
    }




    public function destroy($idPlaylist)
    {
        try {
            $playlist = Playlist::find($idPlaylist);
            $playlist->audios()->detach();
            $playlist->delete();
            return response()->json('Playlist removida com sucesso!');
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao remover playlist", "message:" => $exception->getMessage()]);
        }


    }

}
<file_sep>/gulpfile.js
// including plugins
var concat = require('gulp-concat');

var gulp = require('gulp'),
uglify = require("gulp-uglify");

//Concatenar os arquivos
gulp.task('concacScripts', function() {
    return gulp.src(['./public/assets/js/smooth-scrolling.js',
     './public/assets/js/scrolling-nav.js', 
     './public/assets/js/Chart-rounded.min.js'])
      .pipe(concat('dev/scripts.js'))
      .pipe(gulp.dest('./public/assets/js/'));
});

// Minify file
gulp.task('minifyJS', function () {
    gulp.src('./public/assets/js/dev/scripts.js')// path to your files
    .pipe(uglify())
    .pipe(concat('script.js'))
.pipe(gulp.dest('public/assets/js/dist'));
});

gulp.task('dev', gulp.series('concacScripts','minifyJS'));


<file_sep>/app/Entities/TesteNivelamento/TesteNivelamento.php
<?php

namespace App\Entities\TesteNivelamento;

use App\User;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Auth;

class TesteNivelamento extends Model
{
    protected $table = "teste_nivelamentos";
    
    //Preenchiveis
    protected $fillable = [
        'user_id',
        'titulo',
        'descricao',
        'tempo',
        'recomendacoes'
    ];
    
    public function questoes()
    {
        return $this->hasMany(TesteNivelamentoQuestao::class, 'teste_id')->oldest('created_at');
    }
    
    public function direcionamentos()
    {
        return $this->hasMany(TesteNivelamentoDirecionamento::class, 'teste_id');
    }
    
    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }
    
    public function resultados()
    {
        return $this->hasMany(TesteNivelamentoResultado::class, 'teste_id')
            ->where('user_id', Auth::user()->id)
            ->where('status', 0);
    }
    
}
<file_sep>/app/Http/Controllers/Missoes/Admin/MissoesController.php
<?php

namespace App\Http\Controllers\Missoes\Admin;


use App\Entities\Missao\Missao;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Input;

class MissoesController extends Controller
{

    public function index(Request $request)
    {
        $missoes = Missao::orderBy('id', 'DESC')->paginate(6);

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;
        if($tem_pesquisa)
        {
            $missoes = Missao::where('titulo', 'like', '%' . Input::get('pesquisa') . '%')->paginate(6);
        }

        return view('pages.missoes.admin.index', compact('missoes'));
    }

    public function store(Request $request)
    {
        $this->validate($request, [
            'titulo'    => 'required'
        ]);
        $values = $request->all();
        $values['user_id'] = Auth::user()->id;

        Missao::create($values);
        return redirect()->route('gestao.missoes.listar')->with('message', 'Missão cadastrada com sucesso!');
    }

    public function fetch($id, Request $request)
    {
        $missao = Missao::find($id);

        return $missao->toJson();
    }


    public function update($id, Request $request)
    {
        $this->validate($request, [
            'titulo'    => 'required'
        ]);
        $values = $request->all();
        Missao::find($id)->update($values);

        return redirect()->route('gestao.missoes.listar')->with('message', 'Missão atualizada com sucesso!');
    }


    public function delete($id)
    {
        Missao::find($id)->delete();

        return redirect()->route('gestao.missoes.listar')->with('message', 'Missão excluída com sucesso!');
    }

}
<file_sep>/database/migrations/2019_08_08_111945_create_comentario_topico_curso_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateComentarioTopicoCursoTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('comentario_topico_curso', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('topico_curso_id');
			$table->integer('user_id');
			$table->text('conteudo', 65535);
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('comentario_topico_curso');
	}

}
<file_sep>/app/LiberacaoAplicacaoEscola.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class LiberacaoAplicacaoEscola extends Model
{
    protected $table = 'liberacao_aplicacao_escola';

    //Preenchiveis
    protected $fillable = [
        'aplicacao_id',
        'escola_id',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
    ];

    public function aplicacao()
    {
        return $this->belongsTo('App\Aplicacao');
    }

    public function escola()
    {
        return $this->belongsTo('App\Escola');
    }

}
<file_sep>/database/migrations/2019_08_08_111945_create_plano_aulas_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreatePlanoAulasTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('plano_aulas', function(Blueprint $table)
		{
			$table->increments('id');
			$table->timestamps();
			$table->integer('user_id');
			$table->integer('grade_aula_id');
			$table->string('assunto');
			$table->text('tarefa_classe', 65535);
			$table->text('tarefa_casa', 65535)->nullable();
			$table->date('data')->nullable();
			$table->text('objetivos', 65535)->nullable();
			$table->text('topicos_conhecimento', 65535)->nullable();
			$table->string('habilidades_competencias');
			$table->text('etapas_atividades', 65535)->nullable();
			$table->text('recursos_necessarios', 65535)->nullable();
			$table->text('avaliacao', 65535)->nullable();
			$table->text('metodologia', 65535)->nullable();
			$table->text('tema', 65535)->nullable();
			$table->string('nivel_ensino');
			$table->string('ano_serie')->nullable();
			$table->string('materia');
			$table->integer('quantidade_aulas');
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('plano_aulas');
	}

}
<file_sep>/database/migrations/2019_08_08_111945_create_teste_nivelamento_resposta_questao_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateTesteNivelamentoRespostaQuestaoTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('teste_nivelamento_resposta_questao', function(Blueprint $table)
		{
			$table->increments('id');
			$table->string('correta')->nullable();
			$table->timestamps();
			$table->integer('questao_id');
			$table->string('resposta');
			$table->integer('teste_nivelamento_resultado_id');
			$table->integer('user_id');
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('teste_nivelamento_resposta_questao');
	}

}
<file_sep>/docker/app/start.sh
#!/usr/bin/env sh

_="$(dirname "$0")"

# $_/user_setup www-data
$_/composer

echo "==> Running migration"
php artisan migrate

echo "==> Generating key"
php artisan key:generate

echo "==> Cache config"
php artisan cache:clear
php artisan config:cache
php artisan view:clear

# Start php-fpm
echo "===> Initializing php-fpm"
php-fpm<file_sep>/app/ComentarioPostagemEscola.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class ComentarioPostagemEscola extends Model
{
    protected $table = 'comentario_postagem_escola';

    //Preenchiveis
    protected $fillable = [
        'postagem_id',
        'user_id',
        'conteudo',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
    ];

    public function postagem()
    {
        return $this->belongsTo('App\Postagem');
    }

    public function user()
    {
        return $this->belongsTo('App\User');
    }

}
<file_sep>/public/assets/js/pages/gestao/albuns.min.js
window.enviarAlbum = function () {
    $("#formNovoAlbum #divLoading").addClass("d-none");
    $("#formNovoAlbum #divEditar").addClass("d-none");

    $("#formNovoAlbum #divEnviando").removeClass("d-none");
};

window.atualizarAlbum = function () {
    $("#formEditarAlbum #divLoading").addClass("d-none");
    $("#formEditarAlbum #divEditar").addClass("d-none");

    $("#formEditarAlbum #divEnviando").removeClass("d-none");
};
<file_sep>/app/Http/Controllers/ApiController.php
<?php

namespace App\Http\Controllers;

use App\ResetToken;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Input;

use Auth;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Validator;
use Intervention\Image\Facades\Image;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Escola;
use App\Categoria;
use App\Aplicacao;
use App\Conteudo;
use App\AvaliacaoInstrutor;
use App\Matricula;
use App\Metrica;

use App\AvaliacaoConteudo;
use App\ProgressoConteudo;
use App\CodigoTransmissao;

use App\User;
use App\Turma;
use App\AlunoTurma;
use App\PostagemTurma;
use App\Badge;
use App\BadgeUsuario;

use App\DuvidaProfessor;
use App\ComentarioDuvidaProfessor;

use App\Entities\Glossario\Repository;

class ApiController extends Controller
{
    public function index()
    {
        return response()->json(["success" => "Api para comunicação das aplicações Jean Piaget, para mais informações leia a documentação."], 200, [], JSON_UNESCAPED_UNICODE);
    }




    public function userStore(Request $request)
    {
        $customMessages = [
            'name.required'               => "O campo Nome é obrigatório.",
            'email.required'              => "O campo E-mail é obrigatório.",
            'email.unique'                => "E-mail já foi utilizado.",
            'email.email'                 => "O campo E-mail deve ser um endereço de e-mail válido.",
            "data_nascimento.required"    => "O campo Data de nascimento é obrigatório.",
            "data_nascimento.date_format" => "Data de nascimento é inválida.",
            "password.required"           => "O campo Senha é obrigatório.",
            "password.min"                => "O campo Senha deve ter no mínimo :min caracteres.",
            "password.confirmed"          => "A confirmação de Senha não está correta",
        ];
        $validate = Validator::make($request->all(), [
            'name'            => ['required', 'string', 'max:255'],
            'email'           => ['required', 'string', 'email', 'max:255', 'unique:users'],
            'data_nascimento' => ['required', 'string', 'date_format:d/m/Y'],
            'password'        => ['required', 'string', 'min:6', 'confirmed']
        ], $customMessages);

        if ($validate->fails()) {
            return response()->json(['error' => true, 'errorMessage' => $validate->errors()]);
        }

        $dateInput = str_replace("/", '-', $request->get('data_nascimento'));

        try {
            User::create(
                ['name'             => $request->get('name'),
                 'email'            => $request->get('email'),
                 'data_nascimento'  => date('Y-m-d', strtotime($dateInput)),
                 'password'         => <PASSWORD>($request->get('password')),
                 'ultima_atividade' => date("Y-m-d H:i:s")
                ]);
            return response()->json(['success' => 'Cadastro realizado com sucesso!']);
        } catch (\Exception $exception) {
            return response()->json(['error' => 'Erro ao realizar cadastro. ' . $exception->getMessage()]);
        }
    }




    public function userUpdate(Request $request)
    {
        $userId = Auth::user()->id;

        /**
         * Update profile
         */
        if ($request->get('password') === null) {
            $validate = Validator::make($request->all(), [
                'name'            => ['required', 'string', 'max:255'],
                'data_nascimento' => ['required', 'string']
            ]);
            if ($validate->fails()) {
                return response()->json(['error' => true, 'errorMessage' => $validate->errors()]);
            }
            try {
                User::find($userId)->update([
                    'name'             => $request->get('name'),
                    'data_nascimento'  => date('Y-m-d', strtotime($request->get('data_nascimento'))),
                    'ultima_atividade' => date("Y-m-d H:i:s")
                ]);
                return response()->json(['success' => 'Perfil alterado com sucesso!']);
            } catch (\Exception $exception) {
                return response()->json(['error' => 'Erro ao atualizar perfil. ' . $exception->getMessage()]);
            }
        }


        /**
         * Update password
         */

        $validate = Validator::make($request->all(), [
            'name'            => ['required', 'string', 'max:255'],
            'data_nascimento' => ['required', 'string'],
            'password'        => ['required', 'string', 'min:6', 'confirmed']
        ]);

        if ($validate->fails()) {
            return response()->json(['error' => true, 'errorMessage' => $validate->errors()]);
        }

        try {
            User::find($userId)->update([
                'name'             => $request->get('name'),
                'data_nascimento'  => date('Y-m-d', strtotime($request->get('data_nascimento'))),
                'password'         => <PASSWORD>($request->get('password')),
                'ultima_atividade' => date("Y-m-d H:i:s")
            ]);
            return response()->json(['success' => 'Perfil realizado com sucesso!']);
        } catch (\Exception $exception) {
            return response()->json(['error' => 'Erro ao atualizar perfil. ' . $exception->getMessage()]);
        }


    }




    public function userUpdateImage(Request $request)
    {

        try {
            $userAuth = User::find(Auth::user()->id);
            if ($request->hasFile('image_name') && $request->file('image_name')->isValid()) {

                $name = uniqid($userAuth->id) . kebab_case(uniqid(date('HisYmd')));
                $extension = pathinfo($request->image_name->getClientOriginalName())['extension'];

                if ($name && $extension) {
                    $nameImage = "{$name}.{$extension}";
                } else {
                    $nameImage = "";
                }

                if (Storage::disk('local')->has('uploads/usuarios/perfil/' . $userAuth->img_perfil)) {
                    Storage::disk('local')->delete('uploads/usuarios/perfil/' . $userAuth->img_perfil);
                }
                $upload = $request->image_name->storeAs('uploads/usuarios/perfil', $nameImage);

                if (!$upload) {
                    return response()->json(array('response' => false, 'data' => 'Falha no upload da imagem'), 500);
                }
                $userAuth->update(['img_perfil' => $nameImage]);
                return response()->json('Imagem atualizada com succeso!');
            }

            return response()->json(array('response' => false, 'data' => 'Falha no upload da imagem'), 500);

        } catch (\Exception $exception) {
            return response()->json(['error' => 'Erro ao atualizar imagem. ' . $exception->getMessage()]);
        }
    }




    public function userForgetPass(Request $request)
    {
        $emailInput = $request->get('email');

        $validate = Validator::make($request->all(), ['email' => ['required', 'string', 'email', 'max:255'],]);
        if ($validate->fails()) {
            return response()->json(['error' => true, 'errorMessage' => $validate->errors()]);
        }

        if (User::where('email', $emailInput)->exists() === false) {
            return response()->json(['error' => true, 'errorMessage' => 'E-mail não cadastrado.']);
        }

        $token = md5(uniqid(time(), true));

        if (ResetToken::where('email', '=', $emailInput)->first() != null) {
            $resetToken = ResetToken::where('email', '=', $emailInput)->first();
            $resetToken->delete();

            /*$resetToken->token = $token;
            $resetToken->created_at = date('Y-m-d H:i:s');

            ResetToken::find($resetToken->id)->update([
                'token'      => $token,
                'created_at' => date('Y-m-d H:i:s')
            ]);

            $resetToken->save();*/
        }

        ResetToken::create(['email' => $emailInput, 'token' => $token, 'created_at' => date('Y-m-d H:i:s')]);

        $userEmail = $request->email;
        $userName = ucwords(User::where('email', '=', $request->email)->first()->name);

        $data = ['email' => $userEmail, 'name' => $userName, 'token' => $token];

        Mail::send('mail.reset-email', $data, function ($message) use ($data) {
            $message->from('<EMAIL>', 'Suporte J Piaget');
            $message->to($data['email'], $data['name'])->subject('Link para resetar sua senha');
        });

        return response()->json(['success' => 'Enviamos para seu email um link para resetar sua senha, verifique em sua caixa de entrada!']);

    }




    public function aplicacao($idAplicacao)
    {
        if (App\Aplicacao::find($idAplicacao) != null) {
            $aplicacao = App\Aplicacao::find($idAplicacao);
        } else {
            \Session::flash('warning', 'Aplicação não encontrada!');
            return redirect()->route('catalogo');
        }

        Metrica::create([
            'user_id' => Auth::check() ? Auth::user()->id : 0,
            'titulo'  => 'Jogar aplicação - ' . $aplicacao->id
        ]);

        return view('play.aplicacao-fullscreen')->with(compact('aplicacao'));

    }




    public function postLogin(Request $request)
    {
        if (Auth::attempt(['email' => $request->email, 'password' => $request->password], ($request->get('remember') ? true : false))) {
            return response()->json([
                "success" => "Autenticado com sucesso!",
                "logado"  => Auth::check(),
                "user"    => Auth::user(),
            ]);
        } else {
            return response()->json(["error" => "Usuário ou senha incorretos."]);
        }
    }




    public function logout()
    {
        Auth::logout();

        return response()->json(["success" => "Deslogado com sucesso."]);
    }




    public function getUser()
    {
        if (Auth::check()) {
            $user = User::where('id', Auth::user()->id)
                ->select('id', 'name', 'email', 'img_perfil as avatar', 'nome_completo', 'data_nascimento as born_date', 'ultima_atividade')
                ->first();
            return response()->json(["success" => "Você está autenticado!", "user" => $user]);
            //return response()->json(["success" => "Você está autenticado!", "user" => Auth::user()]);
        } else {
            return response()->json(["error" => "Não autenticado", "auth" => false]);
        }

    }




    public function getAplicacoes(Request $request)
    {
        // dd($request);

        if ($request->categoria != null) {
            if (Categoria::where('titulo', '=', $request->categoria)->first() != null) {
                $categoria = Categoria::where('titulo', 'like', $request->categoria)->first();
            } else {
                $categoria = null;
            }
        } else {
            $categoria = null;
        }

        if ($categoria != null) {
            $aplicacoes = Aplicacao::with('categoria')->where([['status', '=', '1'], ['categoria_id', '=', $categoria->id]]);

            $aplicacoes = $aplicacoes->orWhere([['status', '=', '1'], ['tags', 'like', '%' . $categoria->titulo . '%']]);
        } elseif ($request->marcador != null && $request->marcador != "" && $request->marcador != "0") {
            $aplicacoes = Aplicacao::with('categoria')->where([['status', '=', '1'], ['categoria_id', '=', $request->marcador]]);

            $aplicacoes = $aplicacoes->orWhere([['status', '=', '1'], ['tags', 'like', '%' . $request->marcador . '%']]);
        } else {
            $aplicacoes = Aplicacao::with('categoria')->where([['status', '=', '1']]);
        }

        $aplicacoes = $aplicacoes->get();

        foreach ($aplicacoes as $aplicacao) {
            // $aplicacao->marcadores = json_decode($aplicacao->tags);
            $aplicacao->marcadores = $aplicacao->tags;
        }

        $categorias = Categoria::where([['tipo', '=', 0]])
            ->orWhere([['tipo', '=', 3]])
            // ->take(12)
            // ->distinct()
            ->orderBy('titulo', 'asc')
            ->get()
            ->unique('titulo');

        $marcadores = [];

        foreach (Aplicacao::groupBy('tags')->pluck('tags') as $tags) {
            if ($tags != null) {
                foreach ($tags as $tag) {
                    if (!in_array($tag, $marcadores) && !$categorias->contains('titulo', $tag) && $tag != "") {
                        array_push($marcadores, $tag);
                    }
                }
            }
        }

        return response()->json(["success" => "Aplicações carregadas com sucesso!", "aplicacoes" => $aplicacoes, "categorias" => $categorias, "marcadores" => $marcadores]);
    }




    public function getAplicacao($idAplicacao)
    {
        if (Aplicacao::with('categoria')->find($idAplicacao) != null) {
            $aplicacao = Aplicacao::with('categoria')->find($idAplicacao);

            // $aplicacao->marcadores = json_decode($aplicacao->tags);
            $aplicacao->marcadores = $aplicacao->tags;

            $aplicacao->relacionados = Aplicacao::with('categoria')->where([['id', '!=', $aplicacao->id], ['categoria_id', '=', $aplicacao->categoria_id]])->get();
        } else {
            return response()->json(["error" => "Aplicação não encontrada!"]);
        }

        return response()->json(["success" => "Aplicação encontrada com sucesso!", "aplicacao" => $aplicacao]);
    }




    public function getAplicacaoPlay($idAplicacao)
    {
        if (Aplicacao::find($idAplicacao) != null) {
            $aplicacao = Aplicacao::find($idAplicacao);
        } else {
            return response()->json(["error" => "Aplicação não encontrada!"]);
            // \Session::flash('warning', 'Aplicação não encontrada!');
            // return redirect()->route('catalogo');
        }

        Metrica::create([
            'user_id' => Auth::check() ? Auth::user()->id : 0,
            'titulo'  => 'Jogar aplicação - ' . $aplicacao->id
        ]);

        return redirect(env('APP_URL') . "/uploads/aplicacoes/" . $idAplicacao . "/");

        // return view('play.aplicacao-fullscreen')->with( compact('aplicacao') );
    }




    public function postNovaMetrica(Request $request)
    {
        if ($request->titulo == null) {
            return response()->json(["error" => "Você precisa preencher o título da métrica!"]);
        }

        // if($request->descricao == null)
        // {
        //     return response()->json([ "error" => "Você precisa preencher a descrição da métrica!" ]);
        // }

        Metrica::create([
            'user_id'   => Auth::check() ? Auth::user()->id : 0,
            'titulo'    => $request->titulo,
            'descricao' => $request->descricao
        ]);

        return response()->json(["success" => "Métrica cadastrada com sucesso!"]);
    }




    public function getConteudos()
    {
        if (Input::get('qt') == null)
            $amount = 100;
        else
            $amount = Input::get('qt');

        if (Input::get('ordem') == null)
            $ordem = "recentes";
        else
            $ordem = Input::get('ordem');

        if (Input::get('categoria') == null)
            $categoria = "";
        elseif (Input::get('categoria') == "geral")
            $categoria = "";
        else
            $categoria = Input::get('categoria');

        if ($categoria != null) {
            if (Categoria::where('titulo', '=', $categoria)->first() != null) {
                $categoria = Categoria::where('titulo', '=', $categoria)->first()->id;
            }
        }

        // Carregar aplicacoes

        if (Input::get('pesquisa') == null || Input::get('pesquisa') == "") {
            $pesquisa = null;

            if ($categoria != null)
                $aplicacoes = Aplicacao::take($amount)->where([['status', '=', '1'], ['categoria', '=', $categoria]]);
            else
                $aplicacoes = Aplicacao::take($amount)->where([['status', '=', '1']]);

            if ($categoria != null)
                $conteudos = Conteudo::take($amount)->where([['status', '=', '1'], ['categoria', '=', $categoria]]);
            else
                $conteudos = Conteudo::take($amount)->where([['status', '=', '1']]);
        } else {
            $aplicacoes = Aplicacao::take($amount)->where([['status', '=', '1'], ['titulo', 'like', '%' . Input::get('pesquisa') . '%']])
                ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');

            $conteudos = Conteudo::take($amount)->where([['status', '=', '1'], ['titulo', 'like', '%' . Input::get('pesquisa') . '%']])
                ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        }

        if ($ordem == 'recentes') {
            $aplicacoes = $aplicacoes->orderBy('created_at', 'desc');

            $conteudos = $conteudos->orderBy('created_at', 'desc');

            $ordem = "Mais recentes";
        } elseif ($ordem == 'antigos') {
            $aplicacoes = $aplicacoes->orderBy('created_at', 'asc');

            $conteudos = $conteudos->orderBy('created_at', 'asc');

            $ordem = "Mais antigos";
        } elseif ($ordem == 'alfabetica') {
            $aplicacoes = $aplicacoes->orderBy('titulo', 'asc');

            $conteudos = $conteudos->orderBy('titulo', 'asc');

            $ordem = "Ordem Alfabética";
        }

        $aplicacoes = $aplicacoes->get();

        $conteudos = $conteudos->get();

        $categorias = Categoria::take(8)->get();

        $videos = $conteudos->filter(function ($c) {
            return $c->tipo == 3;
        });
        $slides = $conteudos->filter(function ($c) {
            return ($c->tipo == 4 && (strpos($conteudo->conteudo, ".ppt") !== false || strpos($conteudo->conteudo, ".pptx") !== false));
        });
        $documentos = $conteudos->filter(function ($c) {
            return $c->tipo == 1 || ($c->tipo == 4 && (strpos($conteudo->conteudo, ".ppt") == false && strpos($conteudo->conteudo, ".pptx") == false));
        });

        $apostilas = $conteudos->filter(function ($c) {
            return $c->tipo == 11;
        });

        $success = "Conteúdos carregados com sucesso!";

        return response()->json(compact('success', 'conteudos', 'pesquisa', 'amount', 'ordem', 'categorias'));
        // return response()->json( compact('success', 'conteudos', 'videos', 'slides', 'documentos', 'aplicacoes', 'pesquisa', 'amount', 'ordem', 'categorias') );
    }




    public function getConteudo($idConteudo)
    {
        if (Conteudo::find($idConteudo) != null) {
            $conteudo = Conteudo::find($idConteudo);
        } else {
            return response()->json(["error" => "Conteúdo não encontrado!"]);
        }

        return response()->json(["success" => "Conteúdo encontrado com sucesso!", "conteudo" => $conteudo]);
    }




    public function getConteudoPlay($idConteudo)
    {
        if (Conteudo::find($idConteudo)) {
            $conteudo = Conteudo::find($idConteudo);
        } else {
            return response()->json(["error" => "Conteúdo não encontrado!"]);
        }

        if ($conteudo->status != 1) {
            if (Auth::check() ? (strtolower(Auth::user()->permissao) != "z" && $conteudo->user_id != Auth::user()->id) : true) {
                return response()->json(["error" => "Conteúdo não encontrado!"]);
            }
        }

        if ($conteudo->tipo == 2) {
            if (strpos($conteudo->conteudo, "soundcloud.com") !== false) {
                $conteudo->conteudo = '<iframe width="100%" height="166" scrolling="no" frameborder="no" allow="autoplay" src="https://w.soundcloud.com/player/?url=' . $conteudo->conteudo . '&color=%236766a6&auto_play=false&hide_related=false&show_comments=true&show_user=true&show_reposts=false&show_teaser=true"></iframe>';
            } elseif (strpos($conteudo->conteudo, "http") !== false || strpos($conteudo->conteudo, "www") !== false) {
                $conteudo->conteudo = '<audio controls style="width: 100%;">
                    <source src="' . $conteudo->conteudo . '" type="audio/mp3">
                    Your browser does not support the audio element.
                </audio>';
            } else {
                $conteudo->conteudo = '<audio controls style="width: 100%;">
                    <source src="' . route('conteudo.play.get-arquivo', ['idConteudo' => $idConteudo]) . '" type="audio/mp3">
                    Your browser does not support the audio element.
                </audio>';
            }
        } else if ($conteudo->tipo == 3) {
            if (strpos($conteudo->conteudo, "youtube") !== false || strpos($conteudo->conteudo, "youtu.be") !== false) {
                if (strpos($conteudo->conteudo, "youtu.be") !== false) {
                    $conteudo->conteudo = str_replace("youtu.be", "youtube.com", $conteudo->conteudo);
                }

                $conteudo->conteudo = str_replace("/watch?v=", "/embed/", $conteudo->conteudo);

                if (strpos($conteudo->conteudo, "&") !== false) {
                    $conteudo->conteudo = substr($conteudo->conteudo, 0, strpos($conteudo->conteudo, "&"));
                }

                $conteudo->conteudo = '<iframe src="' . $conteudo->conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                </iframe>';

            } elseif (strpos($conteudo->conteudo, "vimeo") !== false) {
                if (strpos($conteudo->conteudo, "player.vimeo.com") === false)
                    $conteudo->conteudo = str_replace("vimeo.com/", "player.vimeo.com/video/", $conteudo->conteudo);

                $conteudo->conteudo = '<iframe src="' . $conteudo->conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen>
                </iframe>';
            } else {
                $conteudo->conteudo = '<video controls style="width: 100%; height: 41vw;">
                    <source src="' . route('conteudo.play.get-arquivo', ['idConteudo' => $idConteudo]) . '" type="video/mp4">
                    Your browser does not support the audio element.
                </video>';
            }
        } else if ($conteudo->tipo == 4) {
            if (strpos($conteudo->conteudo, ".ppt") !== false || strpos($conteudo->conteudo, ".pptx") !== false) {
                $conteudo->conteudo = '<iframe src="https://view.officeapps.live.com/op/view.aspx?src=' . route('conteudo.play.get-arquivo', ['idConteudo' => $idConteudo]) . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                </iframe>';
            } elseif (strpos($conteudo->conteudo, ".html") !== false) {
                $conteudo->conteudo = '<iframe src="' . route('conteudo.play.get-arquivo', ['idConteudo' => $idConteudo]) . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                </iframe>';
            } else {
                $conteudo->conteudo = '<object data="' . route('conteudo.play.get-arquivo', ['idConteudo' => $idConteudo]) . '" type="application/pdf" style="width: 100%; height: 41vw;">
                </object>';
            }

        }

        $conteudo->qtAvaliacoesPositivas = AvaliacaoConteudo::where([['avaliacao', '=', '1'], ['conteudo_id', '=', $idConteudo]])->count();

        $conteudo->qtAvaliacoesNegativas = AvaliacaoConteudo::where([['avaliacao', '=', '0'], ['conteudo_id', '=', $idConteudo]])->count();

        $conteudo->minhaAvaliacao = AvaliacaoConteudo::where([['user_id', '=', Auth::user()->id], ['conteudo_id', '=', $idConteudo]])->first();

        if (!ProgressoConteudo::where([['conteudo_id', '=', $idConteudo], ['tipo', '=', 2], ['user_id', '=', Auth::user()->id]])->exists()) {
            ProgressoConteudo::create([
                'conteudo_id' => $idConteudo,
                'tipo'        => 2,
                'user_id'     => Auth::user()->id
            ]);
        }

        return view('play.conteudo-fullscreen')->with(compact('conteudo'));
    }




    public function getCodigoTransmissao($idTransmissao)
    {
        $transmissao = CodigoTransmissao::where([['id', '=', $idTransmissao], ['status', '=', 1]])->orWhere([['token', '=', $idTransmissao], ['status', '=', 1]])->first();

        if ($transmissao == null) {
            return response()->json(["error" => "Transmissão não encontrada!"]);
        } else {
            if ($transmissao->tipo == 1 || $transmissao->tipo == 2) {
                return response()->json(["success" => "Código de transmissão encontrado!", 'transmissao' => $transmissao]);
            } else {
                return response()->json(["error" => "Transmissão não encontrada!"]);
            }
        }

        return response()->json(["error" => "Transmissão não encontrada!"]);
    }




    public function __construct(Repository $repository)
    {
        $this->repository = $repository;
    }




    public function getGlossario($letra = 'A')
    {
        if (strlen($letra) == 1) {
            $glossarios = $this->repository->all($letra);
        } else {
            $glossarios = $this->repository->search($letra);
        }

        return response()->json(["success" => "Palavras encontradas!", 'glossarios' => $glossarios, 'letra' => $letra]);
    }




    public function getBadges()
    {
        $badges = Badge::where([['visibilidade', '=', '1']])->get();

        foreach (BadgeUsuario::with('badge')->where('user_id', '=', Auth::user()->id)->get() as $minha) {
            if ($badges->contains(function ($value, $key) use ($minha) {
                return $value->id == $minha->badge->id;
            })) {
                $badges->first(function ($value, $key) use ($minha) {
                    return $value->id == $minha->badge->id;
                })->desbloqueada = true;
            } else {
                $minha = $minha->badge;

                $minha->desbloqueada = true;

                $badges->push($minha);
            }
        }

        return response()->json(["success" => "Medalhas carregadas com sucesso!", 'badges' => $badges]);
    }




    public function getMuralTurma($idTurma)
    {
        if (Input::get('qt') == null)
            $amount = 10;
        else
            $amount = Input::get('qt');

        if (Turma::find($idTurma) == null) {
            return response()->json(["error" => "Turma não encontrada!"]);
        } else {
            $turma = Turma::with('professor', 'postagens_comentarios', 'escola')->find($idTurma);

            if (strpos(Auth::user()->permissao, "G") === false && strpos(Auth::user()->permissao, "Z") === false && $turma->user_id != Auth::user()->id && (AlunoTurma::where([['turma_id', '=', $idTurma], ['user_id', '=', Auth::user()->id]])->first() == null)) {
                return response()->json(["error" => "Você não faz parte desta turma!"]);
            }

            if (strpos(Auth::user()->permissao, "Z") !== false || $turma->user_id == Auth::user()->id) {
                if (md5($turma->id . $turma->created_at) != $turma->codigo_convite) {
                    $newCodigo = md5($turma->id . $turma->created_at);

                    $turma->update([
                        'codigo_convite' => $newCodigo
                    ]);
                }
            }

            $alunos = AlunoTurma::with('user')->where('turma_id', '=', $idTurma)->paginate($amount);

            $success = "Mural carregado com sucesso!";

            return response()->json(compact('success', 'turma', 'alunos', 'amount'));

        }
    }




    public function postMuralTurma($idTurma, Request $request)
    {
        if (Turma::find($idTurma) == null) {
            return response()->json(["error" => "Turma não encontrada!"]);
        } else {
            $turma = Turma::find($idTurma);

            if (strpos(Auth::user()->permissao, "G") === false && strpos(Auth::user()->permissao, "Z") === false && $turma->user_id != Auth::user()->id && (AlunoTurma::where([['turma_id', '=', $idTurma], ['user_id', '=', Auth::user()->id]])->first() == null)) {
                return response()->json(["error" => "Você não faz parte desta turma!"]);
            }

            $postagem = PostagemTurma::create([
                'turma_id' => $idTurma,
                'user_id'  => Auth::user()->id,
                'conteudo' => $request->conteudo
            ]);

            // if($request->arquivo != null)
            // {
            //     $originalName = mb_strtolower( $request->arquivo->getClientOriginalName(), 'utf-8' );

            //     $fileExtension = \File::extension($request->arquivo->getClientOriginalName());
            //     $newFileNameArquivo =  md5( $request->arquivo->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

            //     $pathArquivo = $request->arquivo->storeAs('uploads/turmas/' . $idTurma . '/arquivos', $newFileNameArquivo, 'local');

            //     if(!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo)))
            //     {
            //         \Session::flash('error', 'Não foi possível fazer upload de seu anexo!');
            //     }
            //     else
            //     {
            //         $postagem->update([
            //             'arquivo' => $newFileNameArquivo
            //         ]);
            //     }
            // }

            return response()->json(["success" => "Postagem enviada com sucesso!"]);
        }
    }




    public function getDuvidasProfessor($idProfessor)
    {
        $professor = User::with('escola')->find($idProfessor);

        if ($professor == null) {
            return response()->json(["error" => "Professor não encontrado!"]);
        } else if (strtoupper($professor->permissao) != "P" && strtoupper($professor->permissao) != "G" && strtoupper($professor->permissao) != "Z") {
            return response()->json(["error" => "Professor não encontrado!"]);
        }

        if (AvaliacaoInstrutor::where('instrutor_id', '=', $idProfessor)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $idProfessor)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $duvidas = DuvidaProfessor::where([['professor_id', '=', $idProfessor]])->get();

        foreach ($duvidas as $duvida) {
            $duvida->qt_comentarios = ComentarioDuvidaProfessor::where([['duvida_id', '=', $duvida->id]])->count();
        }

        // dd($duvidas);

        $success = "Duvidas do professor carregadas com sucesso!";

        return response()->json(compact('success', 'duvidas', 'professor', 'avaliacaoInstrutor'));
    }




    public function getDuvidaProfessor($idProfessor, $idDuvida)
    {
        $duvida = DuvidaProfessor::with('professor', 'user', 'comentarios')->has('professor')->has('user')->find($idDuvida);

        // dd($duvida);

        if ($duvida == null) {
            return response()->json(["error" => "Dúvida não encontrada!"]);
        }

        if (AvaliacaoInstrutor::where('instrutor_id', '=', $duvida->professor->id)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $duvida->professor->id)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $success = "Duvida carregada com sucesso!";

        return response()->json(compact('success', 'duvida', 'avaliacaoInstrutor'));
    }




    public function getAvaliacoesProfessor($idProfessor)
    {
        $professor = User::with('escola')->find($idProfessor);

        if ($professor == null) {
            return response()->json(["error" => "Professor não encontrado!"]);
        } else if (strtoupper($professor->permissao) != "P" && strtoupper($professor->permissao) != "G" && strtoupper($professor->permissao) != "Z") {
            return response()->json(["error" => "Professor não encontrado!"]);
        }

        //Relatorios avaliacoes instrutor

        if (AvaliacaoInstrutor::where('instrutor_id', '=', $idProfessor)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $idProfessor)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $avaliacoes = AvaliacaoInstrutor::with('user')->where('instrutor_id', '=', $idProfessor)->orderBy('created_at', 'desc')->get();

        $success = "Avaliações carregadas com sucesso!";

        return response()->json(compact('success', 'professor', 'avaliacoes', 'avaliacaoInstrutor'));
    }




    public function postProgressoConteudo($idConteudo, Request $request)
    {
        if ($request->tipo == null) {
            return response()->json(["error" => "Você deve informar o tipo de conteúdo!"]);
        } elseif ($request->tipo != 1 || $request->tipo != 2) {
            return response()->json(["error" => "Tipo de conteúdo inválido!"]);
        } elseif ($request->progresso == null) {
            return response()->json(["error" => "Você deve informar o progresso do usuário neste conteúdo!"]);
        }

        if (!ProgressoConteudo::where([['conteudo_id', '=', $idConteudo], ['tipo', '=', $request->tipo], ['user_id', '=', Auth::user()->id]])->exists()) {
            ProgressoConteudo::create([
                'conteudo_id' => $idConteudo,
                'tipo'        => $request->tipo,
                'user_id'     => Auth::user()->id,
                'progresso'   => $request->progresso
            ]);

            return response()->json(["success" => "Progresso atualizado com sucesso!"]);
        } else {
            ProgressoConteudo::where([['conteudo_id', '=', $idConteudo], ['tipo', '=', $request->tipo], ['user_id', '=', Auth::user()->id]])->first()->update([
                'progresso' => $request->progresso
            ]);

            return response()->json(["success" => "Progresso atualizado com sucesso!"]);
        }
    }

}
<file_sep>/app/Http/Controllers/Questoes/Admin/QuestoesController.php
<?php

namespace App\Http\Controllers\Questoes\Admin;

use App\Entities\Questoes\Repository as Questoes;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

use App\Entities\TesteNivelamento\TesteNivelamento;

class QuestoesController extends Controller
{
    private $questoes;
    
    public function __construct(Questoes $questoes)
    {
        $this->questoes = $questoes;
    }
    
    public function index()
    {
        $questoes = $this->questoes->all();
        return view('pages.questoes.admin.index', compact('questoes'));
    }
    
    public function indexAjaxAll()
    {
        $questoes = $this->questoes->all();
        return response()->json($questoes);
    }
    
    /*public function indexAjax($id)
    {
        $questao = $this->questoes->find($id);
        return response()->json($questao);
    }*/
    
    
    public function store(Request $request)
    {
        $this->validate($request, ['titulo' => 'required']);
        
        if ($request->get('tipo') == 2) {
            $alternativas = json_encode($request->except('_token', 'titulo', 'descricao', 'tipo', 'alternativa_correta'));
            $this->questoes->store([
                'user_id'          => Auth::user()->id,
                'titulo'           => $request->get('titulo'),
                'descricao'        => $request->get('descricao'),
                'tipo'             => $request->get('tipo'),
                'alternativas'     => $alternativas,
                'resposta_correta' => $request->get('alternativa_correta')
            ]);
        } else {
            $this->questoes->store([
                'user_id'   => Auth::user()->id,
                'titulo'    => $request->get('titulo'),
                'descricao' => $request->get('descricao'),
                'tipo'      => $request->get('tipo')
            ]);
        }
        return redirect()->route('gestao.questoes.listar')->with('message', 'Cadastro realizado com sucesso!');
    }
    
    public function storeAjax(Request $request)
    {
        $this->validate($request, ['titulo' => 'required']);
        
        if ($request->get('tipo') == 2) {
            $alternativas = json_encode($request->except('_token', 'titulo', 'descricao', 'tipo', 'alternativa_correta'));
            $store = $this->questoes->store([
                'user_id'          => Auth::user()->id,
                'titulo'           => $request->get('titulo'),
                'descricao'        => $request->get('descricao'),
                'tipo'             => $request->get('tipo'),
                'alternativas'     => $alternativas,
                'resposta_correta' => $request->get('alternativa_correta')
            ]);
            return $store->id;
        } else {
            $store = $this->questoes->store([
                'user_id'   => Auth::user()->id,
                'titulo'    => $request->get('titulo'),
                'descricao' => $request->get('descricao'),
                'tipo'      => $request->get('tipo')
            ]);
            return $store->id;
        }
        //return "Questão cadastrada com sucesso!";
    }
    
    
    public function update($idQuestao, Request $request)
    {
        $this->validate($request, ['titulo' => 'required']);
        
        if ($request->get('tipo') == 2) {
            $alternativas = json_encode($request->except('_token', 'titulo', 'descricao', 'tipo', 'alternativa_correta'));
            $this->questoes->update($idQuestao, [
                'titulo'           => $request->get('titulo'),
                'descricao'        => $request->get('descricao'),
                'tipo'             => $request->get('tipo'),
                'alternativas'     => $alternativas,
                'resposta_correta' => $request->get('alternativa_correta')
            ]);
        } else {
            $this->questoes->update($idQuestao, [
                'titulo'           => $request->get('titulo'),
                'descricao'        => $request->get('descricao'),
                'tipo'             => $request->get('tipo'),
                'alternativas'     => null,
                'resposta_correta' => null
            ]);
        }
        return redirect()->route('gestao.questoes.listar')->with('message', 'Questão atualizada com sucesso!');
    }
    
    
    public function delete(Request $request)
    {
        $questao = $this->questoes->find($request->idQuestao);
        $TesteNivelamento = TesteNivelamento::get($questao->teste_id);

        if(!$TesteNivelamento->isEmpty()) 
        {
            return redirect()->back()->withErrors("Questão não pode ser excluída, está associada a um teste de nivelamento!");            
        }

        $this->questoes->delete($request->idQuestao);
        return redirect()->route('gestao.questoes.listar')->with('message', 'Questão excluída com sucesso!');
    }
    
    
}
<file_sep>/app/Http/Controllers/Importacao/AulaConteudoController.php
<?php
namespace App\Http\Controllers\Importacao;

use App\Conteudo;
use App\ConteudoAula;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

use Illuminate\Support\Facades\Storage;

use Redirect;

class AulaConteudoController extends ImportacaoController
{

    public function aulaConteudo($idCurso, $idAula, Request $request)
    {
        if($request->hasFile('fileImportAulaConteudo'))
        {
            if($request->file('fileImportAulaConteudo')->getClientOriginalExtension() != 'tz')
            {
                return Redirect::back()->withErrors(['Arquivo de importação inválido!']);
            }

            $userId = Auth::user()->id;
            
            $fileContent = file_get_contents($request->file('fileImportAulaConteudo')->getPathName());
            $decodeAsArray = json_decode($fileContent, true);

            $arrAulaConteudo = (isset($decodeAsArray['aula_conteudo'])) ? $decodeAsArray['aula_conteudo'] : false;            

            if(!$arrAulaConteudo)
            {
                return Redirect::back()->withErrors(['Arquivo de importação não é do tipo aula_conteudo!']);
            }

  
            //Adiciona Conteúdo Importado
            $conteudo = new Conteudo();  
            $conteudo->user_id = $userId;
            $conteudo->forceFill($arrAulaConteudo);
            $conteudo->save();         
            $insertedConteudoId = $conteudo->id;
            
            //Cria Relacionamento do Conteúdo Importado com o Curso/Aula
            $conteudoAula = new ConteudoAula();
            $conteudoAula->ordem = 999;
            $conteudoAula->conteudo_id = $insertedConteudoId;
            $conteudoAula->curso_id = $idCurso;
            $conteudoAula->aula_id = $idAula;
            $conteudoAula->user_id = $userId;
            $conteudoAula->obrigatorio = 1;
            $conteudoAula->save();

            return Redirect::back()->with('message', 'Conteúdo importado com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Arquivo de importação não existe!']);
        }
    }

}<file_sep>/app/Http/Controllers/GamificacaoUsuario/Api/GamificacaoUsuarioController.php
<?php

namespace App\Http\Controllers\GamificacaoUsuario\Api;

use App\Entities\GamificacaoUsuario\GamificacaoUsuario;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;


class GamificacaoUsuarioController extends Controller
{
    
    public function incrementar($idUsuario, Request $request)
    {
        try {
            $user = GamificacaoUsuario::where('user_id', $idUsuario)->first();
            if (empty($user) === true) {
                GamificacaoUsuario::create(['user_id' => $idUsuario, 'xp' => $request->get('xp')]);
            } else {
                $xp = GamificacaoUsuario::where('user_id', $idUsuario)->first();
                GamificacaoUsuario::find($xp->id)->update(['xp' => $xp->xp + $request->get('xp')]);
            }
            
            return response()->json(["success" => "Incrementação adicionada com sucesso!"]);
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao registar a incrementação.", "message:" => $exception->getMessage()]);
        }
    }
    
    
    public function listar($idUsuario)
    {
        try {
            $xp = GamificacaoUsuario::where('user_id', $idUsuario)->select('xp')->first();
            return response()->json($xp);
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao listar.", "message:" => $exception->getMessage()]);
        }
    }
}
<file_sep>/app/Http/Controllers/API/PlaylistController.php
<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use App\Entities\Playlist\Playlist;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Validator;
use Tymon\JWTAuth\Facades\JWTAuth;

class PlaylistController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
      $user = JWTAuth::toUser();

      try {
        $playlists = Playlist::where("user_id", $user->id)->orderBy("id", "DESC")
            ->select("playlists.id", "playlists.user_id", "playlists.user_id as artist", "playlists.titulo", "playlists.created_at")
            ->with(["audios" => function ($query) {
                $query->select("audios.id", "audios.titulo as title", "audios.user_id as artist", "audios.file as url", "audios.descricao");
            }])
            ->get();

        return response()->json(["data" => $playlists]);
      } catch (\Exception $exception) {
          return response()->json(["error" => "Erro ao listar.", "message" => $exception->getMessage()], 500);
      }
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
      $user = JWTAuth::toUser();
      $validate = Validator::make($request->all(), [
          "titulo"   => ["required"],
          "audio_id" => ["required"],
      ], [
          "audio_id.required" => "Selecione pelo menos 1 áudio em sua playlist."
      ]);

      if ($validate->fails())
          return response()->json(["error" => $validate->errors()], 500);

      try {
          $playlist = Playlist::create([
              "user_id" => $user->id,
              "titulo"  => $request->get("titulo")
          ]);
          $playlist->audios()->attach($request->get("audio_id"));
          return response()->json(["message" => "Playlist cadastrada com sucesso!"]);
      } catch (\Exception $exception) {
          return response()->json(["error" => $exception->getMessage()], 500);
      }
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
      $user = JWTAuth::toUser();

      try {
        $playlist = Playlist::where("user_id", $user->id)
            ->select("playlists.id", "playlists.user_id", "playlists.user_id as artist", "playlists.titulo", "playlists.created_at")
            ->with(["audios" => function ($query) {
                $query->select("audios.id", "audios.titulo as title", "audios.user_id as artist", "audios.file as url",
                    "audios.descricao");
            }])
            ->find($id);
        if (!$playlist) {
            return response()->json(["error" => "Nenhuma playlist foi encontrada"], 404);
        }
        return response()->json($playlist);
      } catch (\Exception $exception) {
          return response()->json(["error" => $exception->getMessage()], 500);
      }
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
      $user = JWTAuth::toUser();
      $validate = Validator::make($request->all(), ["titulo" => ["required"]]);

      if ($validate->fails())
        return response()->json(["error" => $validate->errors()], 500);

      try {
          Playlist::where("user_id", $user->id)->find($id)->update(["titulo" => $request->get("titulo")]);
          return response()->json(["message" => "Playlist atualizada com sucesso!"]);
      } catch (\Exception $exception) {
          return response()->json(["error" => $exception->getMessage()], 500);
      }
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
      try {
        $playlist = Playlist::find($id);
        $playlist->audios()->detach();
        $playlist->delete();
        return response()->json(["message" => "Playlist removida com sucesso!"]);
      } catch (\Exception $exception) {
          return response()->json(["error" => $exception->getMessage()], 500);
      }
    }
}
<file_sep>/app/Http/Controllers/ConfiguracaoController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Image;
use Auth;
use Session;

use App\User;
use App\AvaliacaoInstrutor;

use App\Transacao;
use App\ProdutoTransacao;

// use App\EnderecoUser;
use App\EnderecoUser;
use App\ConfiguracoesNotificacoesUser;


class ConfiguracaoController extends Controller
{
    public function index()
    {
        $user = User::with('escola', 'endereco', 'notificacoes')->find(\Auth::user()->id);

        $transacoes = Transacao::where('user_id', '=', Auth::user()->id)->orderBy('created_at', 'desc')->get();

        foreach ($transacoes as $transacao)
        {
            $transacao->produtos = ProdutoTransacao::where([['transacao_id', '=', $transacao->referencia_id], ['user_id', '=', Auth::user()->id]])->get();
        }

        $totalGasto = Transacao::where('user_id', '=', Auth::user()->id)->sum('total');

        foreach ($transacoes as $transacao)
        {
            switch ($transacao->status)
            {
                case 2:
                    $transacao->status_name = "Processando pagamento";
                    break;
                case 3:
                    $transacao->status_name = "Paga";
                    break;
                case 4:
                    $transacao->status_name = "Concluída";
                    break;
                case 5:
                    $transacao->status_name = "Em disputa";
                    break;
                case 6:
                    $transacao->status_name = "Devolvida";
                    break;
                case 7:
                    $transacao->status_name = "Cancelada";
                    break;
                case 8:
                    $transacao->status_name = "Debitado";
                    break;
                case 9:
                    $transacao->status_name = "Retenção temporária";
                    break;

                default:
                    $transacao->status_name = "Aguardando pagamento";
                    break;
            }
        }

        return view('pages.configuracoes-conta.index')->with(compact('user', 'transacoes', 'totalGasto'));
    }

    public function avaliacoes()
    {
        $professor = User::with('escola')->find(Auth::user()->id);

        if ($professor == null) {
            return redirect()->back()->withErrors("Professor não encontrado!");
        } else if (strtoupper($professor->permissao) != "P" && strtoupper($professor->permissao) != "G" && strtoupper($professor->permissao) != "Z") {
            return redirect()->back()->withErrors("Professor não encontrado!");
        }

        //Relatorios avaliacoes instrutor

        if (AvaliacaoInstrutor::where('instrutor_id', '=', $professor->id)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $professor->id)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $avaliacoes = AvaliacaoInstrutor::with('user')->where('instrutor_id', '=', $professor->id)->orderBy('created_at', 'desc')->get();

        return view('professor.avaliacoes')->with(compact('professor', 'avaliacoes', 'avaliacaoInstrutor'));
    }

    public function trocarEmail(Request $request)
    {
        Auth::user()->update([
            'email' => $request->email
        ]);

        Session::flash('success', 'Dados alterados com sucesso!');

        return redirect()->back();
    }

    public function salvarDados(Request $request)
    {
        // dd($request->all());

        if ($request->instituicao == null)
            $request->instituicao = "";

        if ($request->descricao == null)
            $request->descricao = "";

        $user = Auth::user();

        $dataNascimento = $request->data_nascimento != null ? $request->data_nascimento : $user->data_nascimento;
        $dataNascimento = str_replace('/', '-', $dataNascimento);
        $dataNascimento = date('Y-m-d', strtotime($dataNascimento));        

        $user->update([
            'name'          => $request->name != null ? $request->name : $user->name,
            'nome_completo' => $request->nome_completo != null ? $request->nome_completo : $user->nome_completo,
            'telefone'      => $request->telefone != null ? $request->telefone : $user->telefone,
            'instituicao'   => $request->instituicao != null ? $request->name : $user->instituicao,
            'descricao'     => $request->descricao != null ? $request->descricao : $user->descricao,
            'genero'          => $request->genero != null ? $request->genero : $user->genero,
            'data_nascimento' => $dataNascimento,
        ]);

        EnderecoUser::updateOrCreate([
            'user_id' => Auth::user()->id
        ], [
            'user_id'     => Auth::user()->id,
            "cep"         => $request->cep,
            "uf"          => $request->uf,
            "cidade"      => $request->cidade,
            "bairro"      => $request->bairro,
            "logradouro"  => $request->logradouro,
            "numero"      => $request->numero,
            "complemento" => $request->complemento,
        ]);

        Session::flash('success', 'Dados alterados com sucesso!');

        return redirect()->back();
        
    }

    public function trocarFotoPerfil(Request $request)
    {

        $fileExtension = \File::extension($request->foto->getClientOriginalName());

        $newFileName = md5($request->foto->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

        $pathFoto = $request->foto->storeAs('uploads/usuarios/perfil', $newFileName, 'local');

        if ($img = Image::make(file_get_contents($request->foto))) {
            $img->resize(250, null, function ($constraint) {
                $constraint->aspectRatio();
                $constraint->upsize();
            });

            $img->encode('jpg', 85);
            // // $img->save($path);
        }

        // if(!\Storage::disk('local')->put($pathFoto, file_get_contents($request->foto)))
        if (!\Storage::disk('local')->put($pathFoto, $img)) {
            \Session::flash('middle_popup', 'Ops! Algo deu errado.');
            \Session::flash('popup_style', 'danger');
        } else {
            $user = User::find(\Auth::user()->id);

            if ($user->img_perfil != null && $user->img_perfil != "") {
                if (\Storage::disk('local')->has('uploads/usuarios/perfil/' . $user->img_perfil)) {
                    \Storage::disk('local')->delete('uploads/usuarios/perfil/' . $user->img_perfil);
                }
            }

            $user->img_perfil = $newFileName;
            $user->save();
        }

        return redirect()->back();

    }

    public function trocarSenha(Request $request)
    {
        // dd($request);

        $user = \Auth::user();

        if (strlen($request->senha_nova) < 6) {
            \Session::flash('middle_popup', 'A sua nova senha deve ter no mínimo 6 caracteres!');
            \Session::flash('popup_style', 'warning');

            return redirect()->back();
        }

        if (\Hash::check($request->senha_nova, $user->password)) {
            \Session::flash('middle_popup', 'A sua nova senha deve ser diferente da anterior!');
            \Session::flash('popup_style', 'warning');

            return redirect()->back();
        }

        if ($request->senha_nova != $request->senha_confirmacao) {
            \Session::flash('middle_popup', 'A senha de confirmação deve ser idêntica a sua nova senha!');
            \Session::flash('popup_style', 'warning');

            return redirect()->back();
        }

        if (\Hash::check($request->senha_atual, $user->password) == false) {
            \Session::flash('middle_popup', 'A sua antiga senha está incorreta!');
            \Session::flash('popup_style', 'danger');

            return redirect()->back();
        }

        $user->update([
            'password' => \Hash::make($request->senha_nova)
        ]);

        \Session::flash('success', 'Senha alterada com sucesso!');

        return redirect()->back();

    }


    public function notificacoes(Request $request)
    {
        //dd($request->all());
        foreach ($request->all() as $key => $value) {
            if($value == 'on')
            {
                $request[$key] = true;
            }
        }        

        if($request->has('rcb_notif_resp_professor') == false)
        {
            $request->request->add(['rcb_notif_resp_professor' => false]);
        }
        if($request->has('rcb_notif_resp_aluno') == false)
        {
            $request->request->add(['rcb_notif_resp_aluno' => false]);
        }
        if($request->has('rcb_notif') == false)
        {
            $request->request->add(['rcb_notif' => false]);
        }

        ConfiguracoesNotificacoesUser::updateOrCreate(['user_id' => Auth::user()->id], $request->all());

        return redirect()->back()->with('success', 'Configurações de Notificações Salvas com Sucesso!');
        //return redirect()->back();
    }

}
<file_sep>/app/Generals/Presenter/PlanoAula/PlanoAulaAnexoPresenter.php
<?php

namespace App\Generals\Presenter\PlanoAula;


use Laracasts\Presenter\Presenter;

class PlanoAulaAnexoPresenter extends Presenter
{
    public function planoAnexoTipo()
    {
        if ($this->tipo === 1) {
            return 'Atividades';
        }

        if ($this->tipo === 2) {
            return 'Materiais';
        }

        return 'Nenhum tipo encontrado';

        // 1 atividades - 2 materiais
    }
}
<file_sep>/app/ImagemBanco.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

use Carbon\Carbon;


class ImagemBanco extends Model
{
    protected $table = 'imagem_banco';

    //Preenchiveis
    protected $fillable = [
        'id',
        'user_id',
        'escola_id',
        'titulo',
        'descricao',
        'original_name',
        'file_name',
        'visibilidade',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'escola_id' => 1,
        'visibilidade' => 0,
    ];

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }
}
<file_sep>/app/Escola.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class Escola extends Model
{
    //Preenchiveis
    protected $fillable = [
        'user_id',
        'titulo',
        'descricao',
        'capa',
        'postagem_aberta',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'descricao' => '',
        'capa'      => '',
        'postagem_aberta' => 1,
    ];

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

    public function usuarios()
    {
        return $this->hasMany('App\User', 'user_id');
    }

    public function alunos()
    {
        return $this->hasMany('App\User', 'escola_id');
    }

    public function alunos_exp()
    {
        return $this->hasMany('App\User', 'escola_id')->with('gamificacao');
    }

    public function postagens()
    {
        return $this->hasMany('App\PostagemEscola', 'escola_id')->orderBy('created_at', 'desc');
    }

    public function postagens_comentarios()
    {
        return $this->hasMany('App\PostagemEscola', 'escola_id')->with('user', 'comentarios')->orderBy('created_at', 'desc');
    }

    public function postagens_gestao()
    {
        return $this->hasMany('App\PostagemGestaoEscola', 'escola_id')->orderBy('created_at', 'desc');
    }

    public function postagens_gestao_comentarios()
    {
        return $this->hasMany('App\PostagemGestaoEscola', 'escola_id')->with('user', 'comentarios')->orderBy('created_at', 'desc');
    }

    public function avaliacoes()
    {
        return $this->hasMany('App\AvaliacaoEscola', 'escola_id');
    }

    public function avaliacoes_user()
    {
        return $this->hasMany('App\AvaliacaoEscola', 'escola_id')->with('user');
    }

}
<file_sep>/app/Http/Controllers/Anotacao/AnotacaoController.php
<?php

namespace App\Http\Controllers\Anotacao;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;

use App\Entities\Anotacao\Anotacao;

class AnotacaoController extends Controller
{
    public function nova(Request $request)
    {
        if(!Auth::check())
        {
            return response()->json(['error' => 'Você precisa estar logado para realizar anotações!']);
        }
        elseif(Auth::user()->id == null)
        {
            return response()->json(['error' => 'Você precisa estar logado para realizar anotações!']);
        }

        if($request->trecho == null)
            $request->trecho = '';

        if($request->anotacao == null)
            $request->anotacao = '';

        if($request->pos_y == null)
            $request->pos_y = 0;
        if($request->pos_x == null)
            $request->pos_x = 0;
        if($request->start == null)
            $request->start = 0;
        if($request->end == null)
            $request->end = 0;

        $anotacao = Anotacao::create([
            'user_id' => Auth::id(),
            'conteudo_id' => $request->conteudo_id,
            'pagina' => $request->pagina,
            'trecho' => $request->trecho,
            'anotacao' => $request->anotacao,
            'pos_y' => $request->pos_y,
            'pos_x' => $request->pos_x,
            'start' => $request->start,
            'end' => $request->end,
        ]);

        return response()->json(['success' => 'Anotação criada com sucesso!', 'anotacao_id' => $anotacao->id, 'anotacao' => $anotacao]);

    }

    public function deletar($conteudo_id, $anotacao_id)
    {
        if(Anotacao::where([['id', '=', $anotacao_id], ['user_id', '=', Auth::id()], ['conteudo_id', '=', $conteudo_id]])->first() != null)
        {
            Anotacao::find($anotacao_id)->where([['user_id', '=', Auth::id()], ['conteudo_id', '=', $conteudo_id]])->first()->delete();

            return response()->json(['success' => 'Anotação deletada com sucesso!']);
        }
        else
        {
            return response()->json(['error' => 'Anotação não encontrado!']);
        }

    }
}
<file_sep>/app/Http/Controllers/BibliotecaController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Illuminate\Support\Facades\Storage;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Escola;
use App\Categoria;
use App\Conteudo;
use App\Aplicacao;
use App\AvaliacaoConteudo;
use App\AvaliacaoInstrutor;
use App\Metrica;

class BibliotecaController extends Controller
{
    public function index()
    {
        if(Input::get('qt') == null)
            $amount = 100;
        else
            $amount = Input::get('qt');

        if(Input::get('ordem') == null)
            $ordem = "recentes";
        else
            $ordem = Input::get('ordem');

        if(Input::get('categoria') == null)
            $categoria = "";
        elseif(Input::get('categoria') == "geral")
            $categoria = "";
        else
            $categoria = Input::get('categoria');

        if($categoria != null)
        {
            if(Categoria::where('titulo', '=', $categoria)->first() != null)
            {
                $categoria = Categoria::where('titulo', '=', $categoria)->first()->id;
            }
        }

        // Carregar aplicacoes

        if(Input::get('pesquisa') == null || Input::get('pesquisa') == "")
        {
            $pesquisa = null;

            if($categoria != null)
                $aplicacoes = Aplicacao::take($amount)->where([['status', '=', '1'], ['categoria', '=', $categoria]]);
            else
                $aplicacoes = Aplicacao::take($amount)->where([['status', '=', '1']]);

            if($categoria != null)
                $conteudos = Conteudo::take($amount)->where([['status', '=', '1'], ['categoria', '=', $categoria]]);
            else
                $conteudos = Conteudo::take($amount)->where([['status', '=', '1']]);
        }
        else
        {
            $aplicacoes = Aplicacao::take($amount)->where([['status', '=', '1'], ['titulo', 'like', '%' . Input::get('pesquisa') . '%']])
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');

            $conteudos = Conteudo::take($amount)->where([['status', '=', '1'], ['titulo', 'like', '%' . Input::get('pesquisa') . '%']])
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        }

        if($ordem == 'recentes')
        {
            $aplicacoes = $aplicacoes->orderBy('created_at', 'desc');

            $conteudos = $conteudos->orderBy('created_at', 'desc');

            $ordem = "Mais recentes";
        }
        elseif($ordem == 'antigos')
        {
            $aplicacoes = $aplicacoes->orderBy('created_at', 'asc');

            $conteudos = $conteudos->orderBy('created_at', 'asc');

            $ordem = "Mais antigos";
        }
        elseif($ordem == 'alfabetica')
        {
            $aplicacoes = $aplicacoes->orderBy('titulo', 'asc');

            $conteudos = $conteudos->orderBy('titulo', 'asc');

            $ordem = "Ordem Alfabética";
        }

        $aplicacoes = $aplicacoes->get();

        $conteudos = $conteudos->get();

        $categorias = Categoria::take(8)->get();

        $videos = $conteudos->filter(function ($c) {
            return $c->tipo == 3;
        });

        $slides = $conteudos->filter(function ($c) {
            return ($c->tipo == 4 && (strpos($c->conteudo, ".ppt") !== false || strpos($c->conteudo, ".pptx") !== false));
        });

        $documentos = $conteudos->filter(function ($c) {
            return $c->tipo == 1 || ($c->tipo == 4 && (strpos($c->conteudo, ".ppt") == false && strpos($c->conteudo, ".pptx") == false));
        });

        $apostilas = $conteudos->filter(function ($c) {
            return $c->tipo == 11;
        });

        return view('biblioteca')->with( compact('conteudos', 'videos', 'slides', 'apostilas', 'documentos', 'aplicacoes', 'amount', 'ordem', 'categorias') );
    }

}
<file_sep>/app/Entities/TesteNivelamento/TesteNivelamentoDirecionamento.php
<?php

namespace App\Entities\TesteNivelamento;

use Illuminate\Database\Eloquent\Model;

class TesteNivelamentoDirecionamento extends Model
{
    protected $table = "teste_nivelamento_direcionamento";
    
    //Preenchiveis
    protected $fillable = [
        'teste_id',
        'regra',
        'pontuacao',
        'direcionamento'
    ];
}
<file_sep>/database/migrations/2019_08_08_111945_create_conteudos_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateConteudosTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('conteudos', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('user_id');
			$table->string('titulo');
			$table->text('descricao');
			$table->integer('status');
			$table->integer('tipo');
			$table->text('conteudo');
			$table->float('tempo', 10, 0)->nullable();
			$table->integer('duracao')->nullable();
			$table->text('apoio', 65535)->nullable();
			$table->text('fonte')->nullable();
			$table->text('autores')->nullable();
			$table->integer('categoria_id');
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('conteudos');
	}

}
<file_sep>/app/Http/Controllers/BancoImagensController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\ImagemBanco;

class BancoImagensController extends Controller
{
    public function index ()
    {
        $imagens = ImagemBanco::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $imagens = ImagemBanco::when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        })
        ->get();

        return view('gestao.banco-imagens')->with( compact('imagens') );
    }

    public function store(Request $request)
    {
        // dd($request);

        if(isset($request->arquivo_imagem))
        {
            $originalName = mb_strtolower( $request->arquivo_imagem->getClientOriginalName(), 'utf-8' );

            $fileExtension = \File::extension($request->arquivo_imagem->getClientOriginalName());
            $newFileNameArquivo =  md5( $request->arquivo_imagem->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

            $pathArquivo = $request->arquivo_imagem->storeAs('uploads/banco-imagens', $newFileNameArquivo, 'local');

            if(!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo_imagem)))
            {
                return redirect()->back()->with('error', 'Não foi possível fazer upload da imagem, por favor tente novamente!');
            }
        }
        // else if(isset($request->url_imagem))
        // {
        //     $conteudo = $request->url_imagem;
        // }
        else
        {
            return redirect()->back()->with('error', 'Você deve anexar a imagem que deseja fazer upload!');
        }

        ImagemBanco::create([
            'user_id' => \Auth::user()->id,
            'escola_id' => \Auth::user()->escola_id,
            'titulo' => $request->titulo,
            'descricao' => $request->descricao,
            'original_name' => $originalName,
            'file_name' => $newFileNameArquivo,
            'visibilidade' => $request->visibilidade == null ? 0 : $request->visibilidade,
        ]);

        return redirect()->back()->with('message', 'Imagem criada com sucesso!');
    }

    public function update(Request $request)
    {
        // dd($request);

        if(ImagemBanco::find($request->imagem_id) != null)
        {
            $imagem = ImagemBanco::find($request->imagem_id);

            if(isset($request->arquivo_imagem))
            {
                $originalName = mb_strtolower( $request->arquivo_imagem->getClientOriginalName(), 'utf-8' );

                $fileExtension = \File::extension($request->arquivo_imagem->getClientOriginalName());
                $newFileNameArquivo =  md5( $request->arquivo_imagem->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

                $pathArquivo = $request->arquivo_imagem->storeAs('uploads/banco-imagens', $newFileNameArquivo, 'local');

                if(!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo_imagem)))
                {
                    \Session::flash('error', 'Não foi possível fazer upload de seu conteúdo!');
                }
                else
                {
                    if(\Storage::disk('local')->has('uploads/banco-imagens/' . $imagem->file_name))
                    {
                        \Storage::disk('local')->delete('uploads/banco-imagens/' . $imagem->file_name);
                    }

                    $imagem->update([
                        'original_name' => $originalName,
                        'file_name' => $newFileNameArquivo,
                    ]);
                }
            }

            $imagem->update([
                'titulo' => $request->titulo,
                'descricao' => $request->descricao,
                'visibilidade' => $request->visibilidade
            ]);

            return redirect()->back()->with('message', 'Imagem atualizada com sucesso!');
        }
        else
        {
            return response()->json(["response" => false, "data" => "Imagem não encontrada!", 404]);
        }
    }

    public function getImagem($imagem_id)
    {
        if(ImagemBanco::find($imagem_id) != null)
        {
            $imagem = ImagemBanco::find($imagem_id);

            return response()->json(["response" => true, "data" => "Imagem carregada com sucesso!", 'imagem' => $imagem ]);
        }
        else
        {
            return response()->json(["response" => false, "data" => "Imagem não encontrada!", 404]);
        }
    }

    public function getVisualizar($imagem_id)
    {
        if(ImagemBanco::find($imagem_id) != null)
        {
            $imagem = ImagemBanco::find($imagem_id);

            if (\Storage::disk('local')->has('uploads/banco-imagens/' . $imagem->file_name))
            {
                // return \Storage::disk('local')->response('uploads/banco-imagens/' . $imagem->file_name, $imagem->original_name);

                $path = \Storage::disk('local')->path('uploads/banco-imagens/' . $imagem->file_name, $imagem->original_name);



                if (!\File::exists($path)) {

                    abort(404);

                }



                $file = \File::get($path);

                $type = \File::mimeType($path);



                $response = \Response::make($file, 200);

                $response->header("Content-Type", $type);



                return $response;



                // return response()->file( \Storage::disk('local')->get('uploads/banco-imagens/' . $imagem->file_name, $imagem->original_name) );
            }
        }
        else
        {
            // return response()->view('errors.404');
            return redirect('404');
        }
    }

    public function getArquivo($imagem_id)
    {
        if(ImagemBanco::find($imagem_id) != null)
        {
            $imagem = ImagemBanco::find($imagem_id);

            if (\Storage::disk('local')->has('uploads/banco-imagens/' . $imagem->file_name))
            {
                return \Storage::disk('local')->response('uploads/banco-imagens/' . $imagem->file_name, $imagem->original_name);
            }
        }
        else
        {
            // return response()->view('errors.404');
            return redirect('404');
        }
    }

    public function delete(Request $request)
    {
        // dd($request);

        if(ImagemBanco::find($request->imagem_id) != null)
        {
            $imagem = ImagemBanco::find($request->imagem_id);

            if(\Storage::disk('local')->has('uploads/banco-imagens/' . $imagem->file_name))
            {
                \Storage::disk('local')->delete('uploads/banco-imagens/' . $imagem->file_name);
            }

            $imagem->delete();

            return response()->json(["response" => true, "data" => "Imagem excluída com sucesso!", 200]);
        }
        else
        {
            return response()->json(["response" => false, "data" => "Imagem não encontrada!", 404]);
        }
    }

}
<file_sep>/app/Http/Controllers/API/EscolaController.php
<?php

namespace App\Http\Controllers\API;

use App\Escola;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class EscolaController extends Controller
{

    public function index(Request $request)
    {
        try {
            $escola = Escola::orderBy('id', 'DESC')->get(); 

            if(!empty($request->get('aluno')))
            {
                $escola = Escola::where('user_id', $request->get('aluno'))->orderBy('id', 'DESC')->get(); 

                if($escola->isEmpty())
                {
                    return response()->json(['error' => 'Nenhuma escola foi encontrada com esse aluno.']);
                }
            }

            return response()->json($escola);
        } 
        catch (\Exception $exception) 
        {
            return response()->json(["error" => "Erro ao listar.", "message:" => $exception->getMessage()]);
        }
    }



    public function show($id)
    {
        try {
            $escola = Escola::where('id', $id)->orderBy('id', 'DESC')->get(); 

            if ($escola->isEmpty()) {
                return response()->json(['error' => 'Nenhuma escola foi encontrada']);
            }

            return response()->json($escola);
        } 
        catch (\Exception $exception) 
        {
            return response()->json(["error" => "Erro ao listar.", "message:" => $exception->getMessage()]);
        }
    }

}<file_sep>/app/Http/Controllers/Playlist/PlaylistController.php
<?php

namespace App\Http\Controllers\Playlist;

use Illuminate\Support\Facades\Input;

use App\Entities\Audio\Audio;
use App\Entities\Playlist\Playlist;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class PlaylistController extends Controller
{
    public function index()
    {
        $playlists = Playlist::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $playlists->when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $is_admin = strtoupper(Auth::user()->permissao) == "Z";

        $playlists->when($is_admin == false, function ($query) {
            return $query->where('user_id', '=', Auth::user()->id);
        });

        $playlists = $playlists
        ->orderBy('id', 'DESC')
        ->get();

        $audios = Audio::orderBy('id', 'DESC')->get();

        return view('pages.playlist.index', compact('playlists', 'audios'));
    }


    public function store(Request $request)
    {

        $this->validate($request, [
            'titulo'   => 'required',
            'audio_id' => 'required'
        ], [
            'audio_id.required' => 'Selecione pelo menos 1 áudio em sua playlist'
        ]);

        $playlist = Playlist::create([
            'user_id' => Auth::user()->id,
            'titulo'  => $request->get('titulo')
        ]);

        $playlist->audios()->attach($request->get('audio_id'));

        return redirect()->back()->with('message', 'Playlist cadastrada com sucesso!');
        // return redirect()->route('playlists.listar')->with('message', 'Playlist cadastrada com sucesso!');
    }




    public function update(Request $request, $idPlaylist)
    {
        $this->validate($request, [
            'titulo'   => 'required',
            'audio_id' => 'required'
        ], [
            'audio_id.required' => 'Selecione pelo menos 1 áudio em sua playlist'
        ]);

        $playlist = Playlist::find($idPlaylist);
        $playlist->update(['titulo' => $request->get('titulo')]);

        $playlist->audios()->sync($request->get('audio_id'));

        return redirect()->back()->with('message', 'Playlist atualizada com sucesso!');
        // return redirect()->route('playlists.listar')->with('message', 'Playlist atualizada com sucesso!');
    }




    public function destroy($idPlaylist)
    {
        $playlist = Playlist::find($idPlaylist);

        if (!$playlist)
        {
            return redirect()->back()->withErrors(['Playlist não encontrado!']);
        }

        $playlist->audios()->detach();

        $playlist->delete();

        return redirect()->back()->with('message', 'Playlist excluida com sucesso!');
        // return redirect()->route('playlists.listar')->with('message', 'Playlist excluida com sucesso!');
    }


}
<file_sep>/routes/web.php
<?php

use Illuminate\Support\Facades\Route;
use Illuminate\Support\Facades\Input;

use Illuminate\Http\Request;

use App\User;

setlocale(LC_TIME, 'pt_BR', 'pt_BR.utf-8', 'pt_BR.utf-8', 'portuguese');
date_default_timezone_set('America/Sao_Paulo');

\Carbon\Carbon::setLocale('pt_BR');

// Rotas de autenticação
Auth::routes();

// Conteudo
//Aqui fora para funciona com o powerpoint e google docs
Route::get('play/conteudo/{idConteudo}/arquivo', 'ConteudoController@playGetArquivo')->name('conteudo.play.get-arquivo');

//Aqui fora para funciona com o powerpoint e google docs
Route::get('/play/{idCurso}/conteudo/{idAula}/{idConteudo}/arquivo', 'CursoController@playGetArquivo')->name('curso.play.get-arquivo');


// Area de visitantes
Route::group([], function() {

    Route::get('catalogo', 'CatalogoController@index')->name('catalogo');

    // Hub de aplicações
    Route::group(['prefix' => 'hub', 'as' => 'hub.'], function () {
        // Movido para area de visitante
        Route::get('', 'HubController@index')->name('index');

        Route::get('home', 'HubController@index')->name('home');

        Route::get('aplicacao/{idAplicacao}', 'HubController@aplicacao')->name('aplicacao');
    });

});



// Global auth
Route::middleware(['auth'])->group(function () {

    //Notificacao
    Route::get('notificacao/{idNotificacao}/excluir', 'NotificacaoController@excluirNotificacao')->name('notificacao.excluir');

    // Estatisticas aluno
    Route::prefix('estatisticas')->group(function () {
        Route::get('', 'Estatisticas\Alunos\EstatisticasController@index')->name('estatisticas.index');

        Route::get('', 'Estatisticas\Alunos\EstatisticasController@index')->name('estatisticas.index');
    });

    // Ranking
    Route::prefix('ranking')->group(function () {
        Route::get('', 'Ranking\Alunos\RankingController@index')->name('ranking.index');
    });


    // Plano de aulas
    Route::prefix('plano-de-aulas')->group(function () {
        Route::get('/{idPlano}', 'PlanoAulas\Alunos\PlanoAulasController@index')->name('plano.aulas.index');
    });


    // Plano de estudos
    Route::prefix('plano-de-estudos')->group(function () {
        Route::get('/', 'PlanoEstudos\Alunos\PlanoEstudosController@index')->name('plano.estudos.index');
    });


    // lista de favoritos
    Route::prefix('favoritos')->group(function () {
        Route::get('/', 'Favoritos\Alunos\FavoritosController@index')->name('favoritos.index');
        Route::get('/adiciona/{idRef}/{tipo}', 'Favoritos\Alunos\FavoritosController@adiciona')->name('favoritos.adiciona');
        Route::post('/pesquisar', 'Favoritos\Alunos\FavoritosController@search')->name('favoritos.search');
    });


    // historico
    Route::prefix('historico')->group(function () {
        Route::get('/', 'Historico\Alunos\HistoricoController@index')->name('historico.index');
        Route::post('/pesquisar', 'Historico\Alunos\HistoricoController@search')->name('historico.search');
    });

    //Catalogo
    Route::prefix('catalogo')->group(function () {
        Route::get('2', 'Catalogo\Alunos\CatalogoController@index')->name('catalogo');
    });


    //Grade de aula
    Route::prefix('grade-de-aula')->group(function () {
        Route::get('data/{date}/turma/{turma}', 'GradeAula\Alunos\GradeAulaController@index')->name('grade-aula.index');
    });


    //Home, catalogo e curso

    Route::get('/', 'HomeController@index')->name('index');

    Route::get('/home', 'Estatisticas\Alunos\EstatisticasController@index')->name('home');

    // Route::get('/home', 'BibliotecaController@index')->name('home');



    Route::get('/biblioteca', 'BibliotecaController@index')->name('biblioteca');

    // Aplicações
    Route::get('/aplicacao/ultima', 'AplicacaoController@ultimaAplicacao')->name('aplicacao-ultima');

    Route::get('/aplicacao/ultima/play', 'AplicacaoController@playUltimaAplicacao')->name('aplicacao-ultima-play');

    Route::get('/aplicacao/{idAplicacao}', 'AplicacaoController@index')->name('aplicacao');

    Route::get('/aplicacao/{idAplicacao}/play', 'AplicacaoController@playAplicacao')->name('aplicacao-play');

    // Hub de aplicações
    Route::group(['prefix' => 'hub', 'as' => 'hub.'], function () {
        // Movido para area de visitante
        // Route::get('', 'HubController@index')->name('index');

        // Route::get('/home', 'HubController@index')->name('home');

        Route::get('/aplicacao/ultima', 'HubController@ultimaAplicacao')->name('aplicacao-ultima');

        Route::get('/aplicacao/ultima/play', 'HubController@playUltimaAplicacao')->name('aplicacao-ultima-play');

        // Route::get('/aplicacao/{idAplicacao}', 'HubController@aplicacao')->name('aplicacao');

        Route::get('/aplicacao/{idAplicacao}/play', 'HubController@playAplicacao')->name('aplicacao-play');
    });


    // Glossario
    Route::prefix('glossario')->group(function () {

        //Home
        Route::get('', function () {
            return redirect()->route('glossario.palavra', ['word' => 'A']);
        })->name('glossario.index');

        // User
        Route::get('{word}', 'Glossario\Front\GlossarioController@index')->name('glossario.palavra');

        Route::post('busca', 'Glossario\Front\GlossarioController@search')->name('glossario.search');
    });

    // Habilidades
    Route::prefix('habilidades')->group(function () {
        Route::get('/', 'Habilidades\Alunos\HabilidadesController@index')->name('habilidades.listar');
        Route::get('/estatisticas', 'Habilidades\Alunos\HabilidadesController@estatisticas')->name('habilidades.estatisticas.listar');
    });

    // Agenda
    Route::group(['prefix' => 'agenda', 'as' => 'agenda.'], function () {
        Route::get('/', 'Agenda\AgendaController@index')->name('index');
        Route::post('cadastro', 'Agenda\AgendaController@store')->name('cadastro');
        Route::post('atualizar', 'Agenda\AgendaController@update')->name('atualizar');
        Route::post('deletar', 'Agenda\AgendaController@delete')->name('deletar');
        Route::get('filtrar/{idTurma}/mesclar/{mesclar}', 'Agenda\AgendaController@filterCalendar')->name('filtrar');
    });

    // Teste nivelamento
    Route::group(['prefix' => 'teste-nivelamento', 'as' => 'teste.'], function () {
        Route::get('', 'TesteNivelamento\Aluno\TesteNivelamentoController@index')->name('listar');
        Route::get('{idTeste}/exibe', 'TesteNivelamento\Aluno\TesteNivelamentoController@show')->name('exibe');
        Route::get('{idTeste}/questao/{idQuestao}/{resultadoId}/exibe', 'TesteNivelamento\Aluno\TesteNivelamentoController@getQuestao')->name('questao.exibe');
        Route::post('cadastro/questoes', 'TesteNivelamento\Aluno\TesteNivelamentoController@cadastroQuestoes')->name('questao.cadastro');
        Route::get('expira/update/{id}', 'TesteNivelamento\Aluno\TesteNivelamentoController@expiraUpdateAjax')->name('expira.update');
        Route::get('finalizado/{id}', 'TesteNivelamento\Aluno\TesteNivelamentoController@finalizado')->name('finalizado');
    });

    Route::get('/codigo', 'CodigoTransmissaoController@index')->name('codigo-transmissao');

    Route::get('/codigo/{token}', 'CodigoTransmissaoController@token')->name('codigo-transmissao-token');

    // User perfil
    Route::get('perfil-incompleto', 'UserController@perfilIncompleto')->name('perfil-incompleto');

    Route::post('perfil-incompleto/salvar', 'UserController@postPerfilIncompleto')->name('perfil-incompleto-salvar');

    //Player de conteudo
    Route::get('/play/conteudo/{idConteudo}', 'ConteudoController@playConteudo')->name('conteudo.play');

    Route::post('/play/conteudo/{idConteudo}/interacao/enviar', 'ConteudoController@postEnviarInteracaoConteudo')->name('conteudo.play.enviar-interacao-conteudo');

    Route::post('/play/conteudo/{idConteudo}/avaliacao/enviar', 'ConteudoController@postEnviarAvaliacaoConteudo')->name('conteudo.play.enviar-avaliacao-conteudo');

    Route::post('/play/conteudo/{idConteudo}/comentario/enviar', 'ConteudoController@postEnviarComentarioConteudo')->name('conteudo.play.enviar-comentario-conteudo');

    // Route::post('/leitor', 'ConteudoController@postEnviarComentarioConteudo')->name('conteudo.play.enviar-comentario-conteudo');


    //
    // Rotas para leitor de apostila
    //
    // Rotas de anotação e marcador de página
    //

    Route::get('/leitor_apostila/{conteudo_id}', 'ApostilaController@index')->name('leitor-apostila');

    Route::post('/play/conteudo/{conteudo_id}/anotacao/nova', 'Anotacao\AnotacaoController@nova')->name('conteudo.anotacao.nova');

    Route::get('/play/conteudo/{conteudo_id}/anotacao/{anotacao_id}/deletar', 'Anotacao\AnotacaoController@deletar')->name('conteudo.anotacao.deletar');

    Route::get('/play/conteudo/{conteudo_id}/pagina-marcada', 'MarcadorPagina\MarcadorPaginaController@paginaMarcada')->name('conteudo.pagina-marcada');

    Route::get('/play/conteudo/{conteudo_id}/marcar-pagina/{paginaAtual}', 'MarcadorPagina\MarcadorPaginaController@marcarPagina')->name('conteudo.marcar-pagina');

    Route::get('/play/conteudo/{conteudo_id}/marcador/{pagina}/deletar', 'MarcadorPagina\MarcadorPaginaController@deletarMarcador')->name('conteudo.marcador.deletar');


    // Cursos
    Route::get('curso/{idCurso}', 'CursoController@index')->name('curso');

    Route::get('curso/{idCurso}/trancado', 'CursoController@cursoTrancado')->name('curso.trancado');

    Route::post('curso/{idCurso}/trancado/acessar', 'CursoController@postAcessarCursoTrancado')->name('curso.trancado-acessar');

    Route::get('painel/certificado/{idCurso}', 'PainelController@getCertificado')->name('painel.certificado');

    // Forum do curso / Topicos do curso

    Route::get('curso/{curso_id}/topicos', 'TopicoCursoController@index')->name('curso.topicos');

    Route::post('curso/{curso_id}/topico/enviar', 'TopicoCursoController@postNovoTopico')->name('curso.topico-enviar');

    Route::get('curso/{curso_id}/topico/{topico_curso_id}/comentarios', 'TopicoCursoController@topico')->name('curso.topico-respostas');

    Route::post('curso/{curso_id}/topico/{topico_curso_id}/atualizar', 'TopicoCursoController@postAtualizarTopico')->name('curso.topico-atualizar');

    Route::post('curso/{curso_id}/topico/{topico_curso_id}/excluir', 'TopicoCursoController@postExcluirTopico')->name('curso.topico-excluir');

    Route::post('curso/{curso_id}/topico/{topico_curso_id}/comentario/enviar', 'TopicoCursoController@postEnviarComentarioTopico')->name('curso.topico-comentario-enviar');

    Route::post('curso/{curso_id}/topico/{topico_curso_id}/comentario/{idComentario}/excluir', 'TopicoCursoController@postExcluirComentarioTopico')->name('curso.topico-comentario-excluir');

    //Player de curso
    Route::get('/play/{idCurso}', 'CursoController@playCurso')->name('curso.play');

    Route::post('/play/{idCurso}/avalicao/enviar', 'CursoController@postEnviarAvaliacaoCurso')->name('curso.play.enviar-avaliacao-curso');

    Route::post('/play/{idCurso}/professor/avalicao/enviar', 'CursoController@postEnviarAvaliacaoProfessor')->name('curso.play.enviar-avaliacao-professor');

    Route::post('/play/{idCurso}/escola/avaliacao/enviar', 'CursoController@postEnviarAvaliacaoEscola')->name('curso.play.enviar-avaliacao-escola');

    // Route::get('/play/{idCurso}/conteudo/{idAula}/{idConteudo}/arquivo', 'CursoController@playGetArquivo')->name('curso.play.get-arquivo');

    Route::get('/play/{idCurso}/conteudo/{idAula}', 'CursoController@playGetAula')->name('curso.play.get-aula');

    Route::get('/play/{idCurso}/conteudo/{idAula}/{idConteudo}', 'CursoController@playGetConteudo')->name('curso.play.get-conteudo');

    Route::get('/play/{idCurso}/conteudo/{idAula}/{idConteudo}/proximo', 'CursoController@playGetProximoConteudo')->name('curso.play.get-proximo-conteudo');

    Route::post('/play/{idCurso}/{idAula}/{idConteudo}/avaliacao/enviar', 'CursoController@postEnviarAvaliacaoConteudo')->name('curso.play.enviar-avaliacao-conteudo');

    Route::post('/play/{idCurso}/{idAula}/{idConteudo}/comentario/enviar', 'CursoController@postEnviarComentarioConteudo')->name('curso.play.enviar-comentario-conteudo');

    Route::get('/play/{idCurso}/{idAula}/{idConteudo}/mensagens', 'CursoController@getMensagensTransmissao')->name('curso.play.mensagens-transmissao');

    Route::post('/play/{idCurso}/{idAula}/{idConteudo}/mensagem/enviar', 'CursoController@postEnviarMensagemTransmissao')->name('curso.play.enviar-mensagem-transmissao');

    Route::get('/play/{idCurso}/{idAula}/{idConteudo}/comentario/{idComentario}/excluir', 'CursoController@getExcluirComentarioConteudo')->name('curso.play.excluir-comentario-conteudo');

    Route::post('/play/{idCurso}/{idAula}/{idConteudo}/enviar/resposta', 'CursoController@postEnviarResposta')->name('curso.play.enviar-resposta');

    Route::post('/play/{idCurso}/{idAula}/{idConteudo}/enviar/entregavel', 'CursoController@postEnviarEntregavel')->name('curso.play.enviar-entregavel');

    // Matricula do curso
    Route::get('curso/{idCurso}/matricular', 'CursoController@matricular')->name('curso.matricular');

    //Certificado do curso
    Route::get('curso/{idCurso}/certificado', 'CursoController@getCertificado')->name('curso.certificado');

    //Turmas
    Route::get('turmas', 'TurmaController@index')->name('turmas');

    Route::post('turmas/sair', 'TurmaController@postSairTurma')->name('turma-sair');

    Route::get('turma/{idTurma}/mural', 'TurmaController@muralTurma')->name('turma-mural');

    Route::get('turma/{idTurma}/mural/grade', 'TurmaController@gradeAulas')->name('turma-grade-aulas');

    Route::post('turma/{idTurma}/mural/postar', 'TurmaController@postarMuralTurma')->name('turma-mural-postar');

    Route::get('turma/{idTurma}/mural/convite/{idConvite}', 'TurmaController@getConvite')->name('turma-convite');

    Route::get('turma/{idTurma}/mural/postagem/{idPostagem}/arquivo', 'TurmaController@getArquivo')->name('turma-postagem-arquivo');

    Route::post('turma/{idTurma}/mural/postagem/{idPostagem}/excluir', 'TurmaController@postExcluirPostagem')->name('turma-postagem-excluir');

    Route::post('turma/{idTurma}/mural/postagem/{idPostagem}/comentario/enviar', 'TurmaController@postEnviarComentarioPostagem')->name('turma-postagem-comentario-enviar');

    Route::post('turma/{idTurma}/mural/postagem/{idPostagem}/comentario/{idComentario}/excluir', 'TurmaController@postExcluirComentarioPostagem')->name('turma-postagem-comentario-excluir');

    // Mural Escola

    Route::get('escola/{escola_id}/mural', 'EscolaController@muralEscola')->name('escola.mural');

    Route::post('escola/{escola_id}/mural/postar', 'EscolaController@postarMuralEscola')->name('escola.mural-postar');

    Route::get('escola/{escola_id}/mural/postagem/{postagem_id}/arquivo', 'EscolaController@getArquivo')->name('escola.mural-postagem-arquivo');

    Route::post('escola/{escola_id}/mural/postagem/{postagem_id}/excluir', 'EscolaController@postExcluirPostagem')->name('escola.mural-postagem-excluir');

    Route::post('escola/{escola_id}/mural/postagem/{postagem_id}/comentario/enviar', 'EscolaController@postEnviarComentarioPostagem')->name('escola.mural-postagem-comentario-enviar');

    Route::post('escola/{escola_id}/mural/postagem/{postagem_id}/comentario/{idComentario}/excluir', 'EscolaController@postExcluirComentarioPostagem')->name('escola.mural-postagem-comentario-excluir');


    //Canal Professor
    Route::group(['prefix' => 'canal-do-professor', 'as' => 'canal-professor.'], function () {
        Route::get('/{idProfessor}/canal', 'CanalProfessor\CanalProfessorController@index')->name('index');
        Route::get('/{idProfessor}/biblioteca', 'CanalProfessor\CanalProfessorController@biblioteca')->name('biblioteca');
        Route::get('/{idProfessor}/avaliacoes', 'CanalProfessor\CanalProfessorController@avaliacoes')->name('avaliacoes');

        Route::get('/{idProfessor}/duvidas', 'CanalProfessor\CanalProfessorController@duvidas')->name('duvidas');
        Route::get('/{idProfessor}/duvida/{idDuvida}/respostas', 'CanalProfessor\CanalProfessorController@duvida')->name('duvida-respostas');
    });


    //Duvidas com professor
    Route::get('professor/{idProfessor}/duvidas', 'DuvidaController@index')->name('professor.duvidas');

    Route::post('professor/{idProfessor}/duvida/enviar', 'DuvidaController@postNovaDuvida')->name('professor.duvidas-enviar');

    Route::get('professor/{idProfessor}/duvida/{idDuvida}/respostas', 'DuvidaController@duvida')->name('professor.duvida-respostas');

    Route::post('professor/{idProfessor}/duvida/{idDuvida}/atualizar', 'DuvidaController@postAtualizarDuvida')->name('professor.duvida-atualizar');

    Route::post('professor/{idProfessor}/duvida/{idDuvida}/excluir', 'DuvidaController@postExcluirDuvida')->name('professor.duvida-excluir');

    Route::post('professor/{idProfessor}/duvida/{idDuvida}/comentario/enviar', 'DuvidaController@postEnviarComentarioDuvida')->name('professor.duvida-comentario-enviar');

    Route::post('professor/{idProfessor}/duvida/{idDuvida}/comentario/{idComentario}/excluir', 'DuvidaController@postExcluirComentarioDuvida')->name('professor.duvida-comentario-excluir');

    //User infos
    Route::get('painel', 'PainelController@index')->name('painel');

    // Route::get('perfil', 'PainelController@perfil')->name('perfil');
    // Route::get('perfil/medalhas', 'PainelController@badges')->name('perfil.badges');

    // Perfil medalhas / desafios / conquistas
    Route::group(['prefix' => 'perfil', 'as' => 'perfil.'], function () {
        Route::get('/recompensas', 'Badges\Alunos\BadgesController@recompensas')->name('recompensas');
        Route::get('/desafios-concluidos', 'Badges\Alunos\BadgesController@desafios')->name('desafios');
        Route::get('/conquistas', 'Badges\Alunos\BadgesController@conquistas')->name('conquistas');
    });

    //Avaliacoes do professor
    Route::get('professor/{idProfessor}/avaliacoes', 'RelatorioController@avaliacoesProfessor')->name('professor.avaliacoes');

    Route::get('resultados', 'PainelController@resultados')->name('resultados');

    //Certificado do curso painel
    Route::get('painel/certificado/{idCurso}', 'PainelController@getCertificado')->name('painel.certificado');

    //Group Configurações de conta
    Route::group(['prefix' => 'configuracao', 'as' => 'configuracao.'], function () {
        Route::get('/', 'ConfiguracaoController@index')->name('index');

        Route::get('avaliacoes', 'ConfiguracaoController@avaliacoes')->name('avaliacoes');

        Route::post('/usuario/salvar', 'ConfiguracaoController@salvarDados')->name('salvar-dados');

        Route::post('/usuario/trocar-email', 'ConfiguracaoController@trocarEmail')->name('trocar-email');

        Route::post('/usuario/trocar-perfil', 'ConfiguracaoController@trocarFotoPerfil')->name('trocar-foto');

        Route::post('/usuario/trocar-senha', 'ConfiguracaoController@trocarSenha')->name('trocar-senha');

        Route::post('/usuario/notificacoes', 'ConfiguracaoController@notificacoes')->name('notificacoes');
    });

    // Artigos
    Route::group(['prefix' => 'artigos', 'as' => 'artigos.'], function () {
        Route::get('/', 'ArtigosController@index')->name('index');
        Route::get('ler/{artigo_id}-{sluged_title}', 'ArtigosController@lerArtigo')->name('ler');
    });

    // Playlists
    Route::group(['prefix' => 'playlists', 'as' => 'playlists.'], function () {
        Route::get('/', 'Playlist\PlaylistController@index')->name('listar');
        Route::post('/store', 'Playlist\PlaylistController@store')->name('store');
        Route::post('/{idPlaylist}/update', 'Playlist\PlaylistController@update')->name('update');
        Route::post('/{idPlaylist}/excluir', 'Playlist\PlaylistController@destroy')->name('destroy');
    });

    //Grupo de Ajuda / FAQ
    Route::group(['prefix' => 'ajuda', 'as' => 'ajuda.'], function () {

        //Artigos
        Route::get('', 'ArtigoAjudaController@index')->name('index');

        Route::get('artigos', 'ArtigoAjudaController@index')->name('artigos');

        Route::get('artigos/{idArtigo}', 'ArtigoAjudaController@artigo')->name('artigo');

        Route::post('artigos/{idArtigo}/avaliar', 'ArtigoAjudaController@postAvaliarArtigo')->name('artigo-avaliar');

        Route::post('artigos/pesquisar', 'ArtigoAjudaController@postPesquisar')->name('artigos-pesquisar');

    });

    //Grupo de Gestão
    Route::group(['prefix' => 'gestao', 'as' => 'gestao.', 'middleware' => 'gestao'], function () {

        Route::get('', 'GestaoController@index')->name('index');

        Route::get('cursos-professores', 'GestaoController@cursosProfessores')->name('cursos-professores');
        Route::get('ranking-professores', 'GestaoController@rankingProfessores')->name('ranking-professores');

        Route::get('cursos', 'GestaoController@cursos')->name('cursos');

        // Gestão de cursos e conteudo
        Route::get('curso/novo', 'GestaoController@novoCurso')->name('novo-curso');

        Route::post('curso/novo', 'GestaoController@postNovoCurso')->name('novo-curso');

        Route::get('curso/{idCurso}', 'GestaoController@conteudoCurso')->name('curso-conteudo');

        Route::post('curso/{idCurso}/salvar', 'GestaoController@postSalvarCurso')->name('curso-salvar');

        Route::post('curso/{idCurso}/excluir', 'GestaoController@postExcluirCurso')->name('curso-excluir');

        Route::post('curso/{idCurso}/publicar', 'GestaoController@postPublicarCurso')->name('curso-publicar');

        Route::post('curso/{idCurso}/aula/nova', 'GestaoController@postNovaAula')->name('curso.nova-aula');

        Route::get('curso/{idCurso}/aula/{idAula}/editar', 'GestaoController@editarAula')->name('curso.aula-editar');

        Route::get('curso/{idCurso}/exportar', 'Exportacao\CursoController@curso')->name('curso.exportar');
        Route::get('curso/{idCurso}/aula/{idAula}/exportar', 'Exportacao\AulaController@aula')->name('curso.aula-exportar');
        Route::get('curso/{idCurso}/aula/{idAula}/conteudo/{idConteudo}/exportar', 'Exportacao\AulaConteudoController@aulaConteudo')->name('curso.aula-conteudo-exportar');

        Route::post('curso/importar', 'Importacao\CursoController@curso')->name('curso.importar');
        Route::post('curso/{idCurso}/aula/{idAula}/importar', 'Importacao\AulaController@aula')->name('curso.aula-importar');
        Route::post('curso/{idCurso}/aula/{idAula}/conteudo/importar', 'Importacao\AulaConteudoController@aulaConteudo')->name('curso.aula-conteudo-importar');

        Route::get('curso/{idCurso}/aula/{idAula}/reordenar/{index}', 'GestaoController@reordenarAula')->name('curso.aula-reordenar');

        Route::post('curso/{idCurso}/aula/editar', 'GestaoController@postEditarAula')->name('curso.aula-salvar');

        Route::post('curso/{idCurso}/aula/duplicar', 'GestaoController@postDuplicarAula')->name('curso-aula-duplicar');

        Route::post('curso/{idCurso}/aula/excluir', 'GestaoController@postExcluirAula')->name('curso-aula-excluir');

        Route::get('curso/{idCurso}/aula/{idAula}/conteudos', 'GestaoController@aulaConteudos')->name('curso.aula-conteudos');

        Route::post('curso/{idCurso}/aula/conteudos/novo', 'GestaoController@postNovoConteudoCurso')->name('curso.aula-conteudos-novo');

        Route::get('curso/{idCurso}/aula/{idAula}/conteudos/{idConteudo}/editar', 'GestaoController@editarConteudoCurso')->name('curso.aula-conteudos-editar');

        Route::post('curso/{idCurso}/aula/conteudos/salvar', 'GestaoController@postSalvarConteudoCurso')->name('curso.aula-conteudos-salvar');

        Route::get('curso/{idCurso}/aula/{idAula}/conteudo/{idConteudo}/reordenar/{index}', 'GestaoController@reordenarConteudo')->name('curso.conteudo-reordenar');

        Route::post('curso/{idCurso}/conteudo/duplicar', 'GestaoController@postDuplicarConteudoCurso')->name('curso-conteudo-duplicar');

        Route::post('curso/{idCurso}/conteudo/excluir', 'GestaoController@postExcluirConteudoCurso')->name('curso-conteudo-excluir');

        // Entregaveis
        Route::get('entregaveis', 'EntregaveisController@index')->name('entregaveis');

        Route::get('entregaveis/curso/{idCurso}', 'EntregaveisController@getEntregaveisCurso')->name('entregaveis-curso');

        Route::get('entregaveis/arquivo/{idResposta}', 'EntregaveisController@getArquivoEntregavel')->name('entregaveis-arquivo');

        Route::post('entregaveis/curso/{idCurso}/corrigir/{idResposta}', 'EntregaveisController@postCorrigirResposta')->name('entregaveis-resposta-corrigir');

        // Duvidas do professor
        Route::get('professor/{idProfessor}/duvidas', 'DuvidaController@index')->name('professor.duvidas');

        Route::get('professor/{idProfessor}/duvida/{idDuvida}/respostas', 'DuvidaController@duvida')->name('professor.duvida-respostas');

        //  Gestão de Aplicações
        Route::get('aplicacoes', 'AplicacaoController@gestaoAplicacoes')->name('aplicacoes');

        Route::post('aplicacao/enviar', 'AplicacaoController@postCriarAplicacao')->name('aplicacao-nova');

        Route::get('aplicacao/{idAplicacao}/editar', 'AplicacaoController@getAplicacao')->name('aplicacao-editar');

        Route::post('aplicacao/salvar', 'AplicacaoController@postSalvarAplicacao')->name('aplicacao-salvar');

        Route::post('aplicacao/{idAplicacao}/excluir', 'AplicacaoController@postExcluirAplicacao')->name('aplicacao-excluir');

        //Liberação de aplicações por escola
        Route::post('aplicacoes/liberacao/escola/nova', 'LiberacaoController@postLiberarAplicacaoEscola')->name('aplicacoes.liberacao.escola-nova');

        Route::post('aplicacoes/liberacao/escola/{idLiberacao}/excluir', 'LiberacaoController@postExcluirLiberarAplicacaoEscola')->name('aplicacoes.liberacao.escola-excluir');

        //  Categorias
        Route::get('categorias', 'CategoriaController@categorias')->name('categorias');

        Route::post('categorias/nova', 'CategoriaController@postNova')->name('categorias.nova');

        Route::post('categorias/update', 'CategoriaController@postUpdate')->name('categorias.update');

        Route::get('categorias/{idCategoria}', 'CategoriaController@getCategoria')->name('categorias.get');

        Route::get('categorias/{idCategoria}/deletar', 'CategoriaController@deletar')->name('categorias.deletar');


        // Biblioteca de aplicacoes e conteudo
        Route::get('biblioteca', 'GestaoController@biblioteca')->name('biblioteca');

        //Gestão de cursos e conteudo
        Route::post('conteudos/novo', 'GestaoController@postNovoConteudo')->name('conteudo-novo');

        Route::get('conteudos/{idConteudo}/editar', 'GestaoController@editarConteudo')->name('conteudos-editar');

        Route::post('conteudos/salvar', 'GestaoController@postSalvarConteudo')->name('conteudos-salvar');

        Route::post('conteudo/{idConteudo}/excluir', 'GestaoController@postExcluirConteudo')->name('conteudo-excluir');

        //Gestão de turmas
        Route::get('turmas', 'TurmaController@index')->name('turmas');

        Route::post('turmas/nova', 'TurmaController@postNovaTurma')->name('nova-turma');

        Route::post('turmas/excluir', 'TurmaController@postExcluirTurma')->name('turma-excluir');

        Route::get('turma/{idTurma}/mural', 'TurmaController@muralTurma')->name('turma-mural');

        Route::get('turma/{idTurma}/mural/modo', 'TurmaController@modoPostagem')->name('turma-modo-postagem');

        Route::get('turma/{idTurma}/mural/convite/gerar', 'TurmaController@gerarConvite')->name('turma-gerar-convite');

        Route::post('turma/{idTurma}/alunos/convidar', 'TurmaController@postConvidarAlunos')->name('turma-convidar-alunos');

        Route::get('turma/{idTurma}/alunos/{idAluno}/remover', 'TurmaController@removerAluno')->name('turma-remover-aluno');

        Route::post('turma/{idTurma}/aplicacao/liberar', 'AplicacaoController@postLiberacaoAplicacao')->name('aplicacao-liberar');

        Route::post('turma/{idTurma}/transmissao/nova', 'CodigoTransmissaoController@postNovoCodigoTransmissao')->name('transmissao-nova');

        Route::post('transmissao/{idTransmissao}/excluir', 'CodigoTransmissaoController@postExcluirCodigoTransmissao')->name('transmissao-excluir');

        Route::get('transmissao/gerar-token', 'CodigoTransmissaoController@getTokenRandomico')->name('transmissao-token');

        // Mural escola
        Route::get('escola/{escola_id}/mural', 'EscolaController@muralEscola')->name('escola.mural');

        Route::get('escola/{escola_id}/mural/modo', 'EscolaController@modoPostagem')->name('escola.mural-modo-postagem');

        // Mural Gestão da  Escola

        Route::get('escola/{escola_id}/mural-gestao', 'EscolaController@muralGestaoEscola')->name('escola.mural-gestao');

        Route::post('escola/{escola_id}/mural-gestao/postar', 'EscolaController@postarMuralGestaoEscola')->name('escola.mural-gestao-postar');

        Route::get('escola/{escola_id}/mural-gestao/postagem/{postagem_id}/arquivo', 'EscolaController@getArquivoGestao')->name('escola.mural-gestao-postagem-arquivo');

        Route::post('escola/{escola_id}/mural-gestao/postagem/{postagem_id}/excluir', 'EscolaController@postExcluirPostagemGestao')->name('escola.mural-gestao-postagem-excluir');

        Route::post('escola/{escola_id}/mural-gestao/postagem/{postagem_id}/comentario/enviar', 'EscolaController@postEnviarComentarioPostagemGestao')->name('escola.mural-gestao-postagem-comentario-enviar');

        Route::post('escola/{escola_id}/mural-gestao/postagem/{postagem_id}/comentario/{idComentario}/excluir', 'EscolaController@postExcluirComentarioPostagemGestao')->name('escola.mural-gestao-postagem-comentario-excluir');


        //Gestão de turmas - grade aulas
        Route::get('turma/{idTurma}/grade/listar', 'GradeAula\Admin\GradeAulaController@listar')->name('grade-listar');
        Route::post('turma/{idTurma}/grade/nova', 'GradeAula\Admin\GradeAulaController@nova')->name('grade-nova');
        Route::post('turma/grade/atualizar', 'GradeAula\Admin\GradeAulaController@atualizar')->name('grade-atualizar');
        Route::post('turma/grade/deletar', 'GradeAula\Admin\GradeAulaController@deletar')->name('grade-deletar');

        // Glossario
        Route::get('glossario', function () {
            return redirect()->route('gestao.glossario', ['word' => 'A']);
        })->name('glossario.index');

        Route::post('glossario/salvar', 'Glossario\Admin\GlossarioController@store')->name('glossario.salvar');

        Route::post('glossario/excluir', 'Glossario\Admin\GlossarioController@delete')->name('glossario-excluir');

        Route::get('glossario/{word}', 'Glossario\Admin\GlossarioController@create')->name('glossario');

        //Relatorios
        Route::get('relatorios', 'RelatorioController@index')->name('relatorios');

        // Escolas
        Route::get('escolas', 'EscolaController@escolas')->name('escolas');

        Route::get('escola/{idEscola}/painel', 'EscolaController@painelEscola')->name('escola-painel');

        Route::post('escola/enviar', 'EscolaController@postCriarEscola')->name('escola-nova');

        Route::get('escola/{idEscola}/editar', 'EscolaController@getEscola')->name('escola-editar');

        Route::post('escola/salvar', 'EscolaController@postSalvarEscola')->name('escola-salvar');

        Route::post('escola/excluir', 'EscolaController@postExcluirEscola')->name('escola-excluir');


        // Códigos de acesso da escola
        Route::get('escola/codigos', 'CodigoAcessoEscolaController@index')->name('escola.codigos');

        Route::post('escola/{idEscola}/codigos/gerar', 'CodigoAcessoEscolaController@postGerarCodigosAcesso')->name('escola.codigos-gerar');

        Route::post('escola/{idEscola}/codigo/{idCodigo}/excluir', 'CodigoAcessoEscolaController@postExcluirCodigoAcesso')->name('escola.codigo-excluir');

        // Metricas
        Route::get('metricas', 'MetricaController@getMetricas')->name('metricas');

        // Route::get('metrica', 'MetricaController@getMetrica')->name('metrica');

        Route::get('metrica/{titulo}', 'MetricaController@getMetrica')->name('metrica');

        // Badges
        Route::prefix('badges')->group(function () {
            Route::get('/', 'Badges\Admin\BadgesController@index')->name('badges.listar');
            Route::post('/excluir', 'Badges\Admin\BadgesController@delete')->name('badges.excluir');
            Route::post('/cadastrar', 'Badges\Admin\BadgesController@store')->name('badges.cadastrar');
            Route::post('/atualizar/{idBadge}', 'Badges\Admin\BadgesController@update')->name('badges.atualizar');
            Route::post('/atualizar/icone/{idBadge}', 'Badges\Admin\BadgesController@updateIconBadge')->name('badges.atualizar.icone');
        });


        // Desafios
        Route::group(['prefix' => 'desafios', 'as' => 'desafios.'], function () {
            Route::get('/', 'Desafios\Admin\DesafiosController@index')->name('listar');
            Route::post('/cadastrar', 'Desafios\Admin\DesafiosController@store')->name('cadastrar');
            Route::get('/buscar/{idDesafio}', 'Desafios\Admin\DesafiosController@fetch')->name('buscar');
            Route::post('/atualizar/{idDesafio}', 'Desafios\Admin\DesafiosController@update')->name('atualizar');
            Route::post('/excluir/{idDesafio}', 'Desafios\Admin\DesafiosController@delete')->name('excluir');
        });

        // Missoes
        Route::group(['prefix' => 'missoes', 'as' => 'missoes.'], function () {
            Route::get('/', 'Missoes\Admin\MissoesController@index')->name('listar');
            Route::post('/cadastrar', 'Missoes\Admin\MissoesController@store')->name('cadastrar');
            Route::get('/buscar/{idMissao}', 'Missoes\Admin\MissoesController@fetch')->name('buscar');
            Route::post('/atualizar/{idMissao}', 'Missoes\Admin\MissoesController@update')->name('atualizar');
            Route::post('/excluir/{idMissao}', 'Missoes\Admin\MissoesController@delete')->name('excluir');
        });

        // Conquistas
        Route::group(['prefix' => 'conquistas', 'as' => 'conquistas.'], function () {
            Route::get('/', 'Conquistas\Admin\ConquistasController@index')->name('listar');
            Route::post('/cadastrar', 'Conquistas\Admin\ConquistasController@store')->name('cadastrar');
            Route::get('/buscar/{idConquista}', 'Conquistas\Admin\ConquistasController@fetch')->name('buscar');
            Route::post('/atualizar/{idConquista}', 'Conquistas\Admin\ConquistasController@update')->name('atualizar');
            Route::post('/excluir/{idConquista}', 'Conquistas\Admin\ConquistasController@delete')->name('excluir');
        });

        // Recompensas Virtuais
        Route::group(['prefix' => 'recompensas-virtuais', 'as' => 'recompensas-virtuais.'], function () {
            Route::get('/', 'RecompensasVirtuais\Admin\RecompensasVirtuaisController@index')->name('listar');
            Route::post('/cadastrar', 'RecompensasVirtuais\Admin\RecompensasVirtuaisController@store')->name('cadastrar');
            Route::get('/buscar/{idRecompensaVirtual}', 'RecompensasVirtuais\Admin\RecompensasVirtuaisController@fetch')->name('buscar');
            Route::post('/atualizar/{idRecompensaVirtual}', 'RecompensasVirtuais\Admin\RecompensasVirtuaisController@update')->name('atualizar');
            Route::post('/excluir/{idRecompensaVirtual}', 'RecompensasVirtuais\Admin\RecompensasVirtuaisController@delete')->name('excluir');
        });

        // Recompensas Extra-Jogo
        Route::group(['prefix' => 'recompensas-extra-jogo', 'as' => 'recompensas-extra-jogo.'], function () {
            Route::get('/', 'RecompensasExtraJogo\Admin\RecompensasExtraJogoController@index')->name('listar');
            Route::post('/cadastrar', 'RecompensasExtraJogo\Admin\RecompensasExtraJogoController@store')->name('cadastrar');
            Route::get('/buscar/{idRecompensaExtraJogo}', 'RecompensasExtraJogo\Admin\RecompensasExtraJogoController@fetch')->name('buscar');
            Route::post('/atualizar/{idRecompensaExtraJogo}', 'RecompensasExtraJogo\Admin\RecompensasExtraJogoController@update')->name('atualizar');
            Route::post('/excluir/{idRecompensaExtraJogo}', 'RecompensasExtraJogo\Admin\RecompensasExtraJogoController@delete')->name('excluir');
        });

        // Habilidades
        Route::group(['prefix' => 'habilidades', 'as' => 'habilidades.'], function () {
            Route::get('/', 'Habilidades\Admin\HabilidadesController@index')->name('listar');
            Route::post('/excluir', 'Habilidades\Admin\HabilidadesController@delete')->name('excluir');
            Route::post('/cadastrar', 'Habilidades\Admin\HabilidadesController@store')->name('cadastrar');
            Route::post('/atualizar/{idBadge}', 'Habilidades\Admin\HabilidadesController@update')->name('atualizar');
        });


        // Banco de Questões
        Route::group(['prefix' => 'banco-de-questoes', 'as' => 'questoes.'], function () {
            Route::get('/', 'Questoes\Admin\QuestoesController@index')->name('listar');
            Route::get('/ajax', 'Questoes\Admin\QuestoesController@indexAjaxAll')->name('listar.ajaxall');
            // Route::get('/ajax/{id}', 'Questoes\Admin\QuestoesController@indexAjax')->name('listar.ajax');
            Route::post('/excluir', 'Questoes\Admin\QuestoesController@delete')->name('excluir');
            Route::post('/cadastrar', 'Questoes\Admin\QuestoesController@store')->name('cadastrar');
            Route::post('/cadastrar/ajax', 'Questoes\Admin\QuestoesController@storeAjax')->name('cadastrar.ajax');
            Route::post('/atualizar/{idQuestao}', 'Questoes\Admin\QuestoesController@update')->name('atualizar');
        });

        // Teste de nivelamento
        Route::group(['prefix' => 'teste-de-nivelamento', 'as' => 'teste.'], function () {
            Route::get('/', 'TesteNivelamento\Admin\TesteNivelamentoController@index')->name('listar');
            Route::get('/editar/{idTeste}', 'TesteNivelamento\Admin\TesteNivelamentoController@edit')->name('editar');
            Route::post('/excluir', 'TesteNivelamento\Admin\TesteNivelamentoController@delete')->name('excluir');
            Route::post('/cadastrar', 'TesteNivelamento\Admin\TesteNivelamentoController@store')->name('cadastrar');
            Route::post('/atualizar/{idTeste}', 'TesteNivelamento\Admin\TesteNivelamentoController@update')->name('atualizar');
            Route::get('/resultados/{idTeste}', 'TesteNivelamento\Admin\TesteNivelamentoController@listarResultados')->name('resultados');
            Route::get('/resultados/exibe/{idResultado}', 'TesteNivelamento\Admin\TesteNivelamentoController@corrigeResultado')->name('resultado.exibe');
            Route::get('/resultados/correcao/{idRespostaQuestao}/{value}', 'TesteNivelamento\Admin\TesteNivelamentoController@correcaoResultado')->name('resultado.correcao');
        });

        // Plano de aulas
        Route::group(['prefix' => 'plano-de-aulas', 'as' => 'plano-aulas.'], function () {
            Route::get('/', 'PlanoAulas\Admin\PlanoAulasController@index')->name('listar');
            Route::post('/cadastrar', 'PlanoAulas\Admin\PlanoAulasController@store')->name('cadastrar');
            Route::post('/atualizar/{idPlano}', 'PlanoAulas\Admin\PlanoAulasController@update')->name('atualizar');
            Route::post('/excluir', 'PlanoAulas\Admin\PlanoAulasController@delete')->name('excluir');
            Route::get('/getDates/{idGrade}', 'PlanoAulas\Admin\PlanoAulasController@getDaysAjax')->name('ajax');
            Route::post('/filtrar', 'PlanoAulas\Admin\PlanoAulasController@filtrar')->name('filtrar');
            Route::post('/busca', 'PlanoAulas\Admin\PlanoAulasController@busca')->name('busca');
        });

        // Artigos
        Route::group(['prefix' => 'artigos', 'as' => 'artigos.'], function () {
            Route::get('/', 'ArtigosController@gestaoArtigos')->name('index');
            Route::get('/novo', 'ArtigosController@create')->name('novo');
            Route::get('{artigo_id}', 'ArtigosController@getArtigo')->name('get');
            Route::get('ler/{artigo_id}-{sluged_title}', 'ArtigosController@lerArtigo')->name('ler');
            Route::get('{artigo_id}/editar', 'ArtigosController@editarArtigo')->name('editar');
            Route::post('{artigo_id}/excluir', 'ArtigosController@delete')->name('excluir');
            Route::post('/cadastrar', 'ArtigosController@store')->name('cadastrar');
            Route::post('/atualizar', 'ArtigosController@update')->name('atualizar');
        });

        // Banco de imagens
        Route::group(['prefix' => 'banco-imagens', 'as' => 'banco-imagens.'], function () {
            Route::get('/', 'BancoImagensController@index')->name('index');
            Route::get('{imagem_id}', 'BancoImagensController@getImagem')->name('get');
            Route::get('{imagem_id}/visualizar', 'BancoImagensController@getVisualizar')->name('visualizar');
            Route::get('{imagem_id}/arquivo', 'BancoImagensController@getArquivo')->name('baixar');
            Route::post('{imagem_id}/excluir', 'BancoImagensController@delete')->name('excluir');
            Route::post('/cadastrar', 'BancoImagensController@store')->name('cadastrar');
            Route::post('/atualizar', 'BancoImagensController@update')->name('atualizar');
        });

        // Trilhas
        Route::group(['prefix' => 'trilhas', 'as' => 'trilhas.'], function () {
            Route::get('/', 'Trilhas\Admin\TrilhasController@index')->name('listar');
            Route::get('/nova', 'Trilhas\Admin\TrilhasController@create')->name('create');
            Route::post('/store', 'Trilhas\Admin\TrilhasController@store')->name('store');
            Route::get('/{idTrilha}/editar', 'Trilhas\Admin\TrilhasController@edit')->name('edit');
            Route::post('/{idTrilha}/update', 'Trilhas\Admin\TrilhasController@update')->name('update');
            Route::post('/{idTrilha}/excluir', 'Trilhas\Admin\TrilhasController@destroy')->name('destroy');
        });

        // Album
        Route::group(['prefix' => 'albuns', 'as' => 'albuns.'], function () {
            Route::get('/', 'Album\Admin\AlbumController@index')->name('listar');
            Route::get('/nova', 'Album\Admin\AlbumController@create')->name('create');
            Route::post('/store', 'Album\Admin\AlbumController@store')->name('store');
            Route::get('/{idAlbum}/editar', 'Album\Admin\AlbumController@edit')->name('edit');
            Route::post('/{idAlbum}/update', 'Album\Admin\AlbumController@update')->name('update');
            Route::post('/{idAlbum}/excluir', 'Album\Admin\AlbumController@destroy')->name('destroy');
        });

        // Audios
        Route::group(['prefix' => 'audios', 'as' => 'audios.'], function () {
            Route::get('/', 'Audio\Admin\AudioController@index')->name('listar');
            Route::post('/store', 'Audio\Admin\AudioController@store')->name('store');
            Route::post('/{idAudio}/update', 'Audio\Admin\AudioController@update')->name('update');
            Route::post('/{idAudio}/excluir', 'Audio\Admin\AudioController@destroy')->name('destroy');
            Route::get('/{idAudio}/interacoes', 'AudioInteracoes\Admin\AudioInteracoesController@view')->name('interacoes');
        });

        // Roteiros
        Route::group(['prefix' => 'roteiros', 'as' => 'roteiros.'], function () {
            Route::get('/', 'Roteiros\Admin\RoteirosController@index')->name('listar');
            Route::post('/store', 'Roteiros\Admin\RoteirosController@store')->name('store');
            Route::post('/{idRoteiro}/update', 'Roteiros\Admin\RoteirosController@update')->name('update');
            Route::post('/{idRoteiro}/view', 'Roteiros\Admin\RoteirosController@view')->name('view');
            Route::post('/{idRoteiro}/destroy', 'Roteiros\Admin\RoteirosController@destroy')->name('destroy');
            Route::post('/search', 'Roteiros\Admin\RoteirosController@index')->name('search');
            Route::post('/updateStatusTopico', 'Roteiros\Admin\RoteirosController@ajaxUpdateStatusTopico')->name('updateStatusTopico');
        });

        // Playlists
        Route::group(['prefix' => 'playlists', 'as' => 'playlists.'], function () {
            Route::get('/', 'Playlist\PlaylistController@index')->name('listar');
        });

        // Interações de Audios
        Route::group(['prefix' => 'audios-interacoes', 'as' => 'audios-interacoes.'], function () {
            Route::get('/', 'AudioInteracoes\Admin\AudioInteracoesController@index')->name('listar');
            Route::post('/store', 'AudioInteracoes\Admin\AudioInteracoesController@store')->name('store');
            Route::post('/{idAudio}/update', 'AudioInteracoes\Admin\AudioInteracoesController@update')->name('update');
            Route::get('/{idAudio}/view', 'AudioInteracoes\Admin\AudioInteracoesController@view')->name('view');
            Route::post('/{idAudioInteracao}/destroy', 'AudioInteracoes\Admin\AudioInteracoesController@destroy')->name('destroy');
            Route::post('/search', 'AudioInteracoes\Admin\AudioInteracoesController@index')->name('search');
        });

        Route::resource('gamificacao', 'GamificacaoController')->only([
            'index',
            'store',
            //'show',
        ]);

        //Usuarios
        Route::get('usuarios', 'DashboardController@usuarios')->name('usuarios');

        Route::post('usuarios/novo', 'UserController@postNovo')->name('usuarios.novo');

        Route::get('usuarios/{idUsuario}/editar', 'UserController@getUsuario')->name('usuarios.editar');

        Route::post('usuarios/salvar', 'UserController@update')->name('usuarios.salvar');

        Route::get('usuarios/{idUsuario}/deletar', 'UserController@delete')->name('usuarios.deletar');

        //Grupo Ajuda

        Route::group(['prefix' => 'ajuda', 'as' => 'ajuda.'], function () {

            //Artigos
            Route::get('artigos', 'ArtigoAjudaController@getAdmin')->name('artigos');

            Route::get('artigos/{idArtigo}', 'ArtigoAjudaController@getArtigo')->name('artigo');

            Route::post('artigos/novo', 'ArtigoAjudaController@postNovo')->name('artigo-novo');

            Route::post('artigos/atualizar', 'ArtigoAjudaController@postAtualizar')->name('artigo-update');

            Route::get('artigos/{idArtigo}/deletar', 'ArtigoAjudaController@getDeletarArtigo')->name('artigo-deletar');

        });

    });

    //Grupo Dashboard
    Route::group(['prefix' => 'dashboard', 'as' => 'dashboard.', 'middleware' => 'admin'], function () {

        //Financeiro
        Route::get('financeiro', 'FinanceiroController@index')->name('financeiro');

        // Usar apenas se não obtiver linha de comando
        Route::get('/artisan-clearall', function () {
            Artisan::call('config:clear');

            Artisan::call('cache:clear');

            Artisan::call('view:clear');

            return 'Comando artisan executado com sucesso!';
        });

        // Documentação
        Route::prefix('documentacao')->group(function () {
            Route::prefix('api')->group(function () {
                Route::get('/', 'Documentacao\Api\DocumentacaoController@index')->name('doc.api.index');
            });
        });
    });

    //Contato

    Route::get('/contato', 'ContatoController@index')->name('contato');

    Route::post('/contato', 'ContatoController@post')->name('contato.enviar');

    //User image

    Route::get('/usuarios/{idUsuarios}/perfil/image', 'UserController@imagemPerfil')->name('usuario.perfil.image');

    // Logout routes
    Route::get('/sair', function () {
        Session::flush();
        return redirect()->to('/');
    })->name('sair');

    Route::post('/logout', function () {
        Session::flush();
        return redirect()->to('/');
    })->name('logout');


    // Fim global auth middleware
});

//User passwords

Route::get('/esqueci-senha', 'UserController@esqueciSenha')->name('usuario.esqueci-senha');

Route::post('/esqueci-senha', 'UserController@postEsqueciSenha')->name('usuario.esqueci-senha');

Route::get('/resetar-senha/{token}', 'UserController@resetarSenha')->name('usuario.resetar-senha');

Route::post('/resetar-senha', 'UserController@postResetarSenha')->name('usuario.resetar-senha');

// Routes Login/Cadastro

Route::get('/entrar', 'HomeController@entrar')->name('entrar');

Route::get('/logar', 'HomeController@entrar')->name('logar');

Route::get('/registrar', 'HomeController@registrar')->name('registrar');

Route::get('/cadastrar', 'HomeController@registrar')->name('cadastrar');

// Redirecionador temporario

Route::get('/uploads/aplicacoes/{id_aplicacao}/jogo', function ($id_aplicacao) {

    return redirect("/uploads/aplicacoes/$id_aplicacao/");

});

// Api
Route::group([
    'prefix' => 'api/v1',
    'as'     => 'api.v1',
    // 'middleware' => 'cors'
], function () {

    Route::get('/', 'ApiController@index')->name('index');

    // Gamificação
    Route::post('gamificacao/usuario/{idUsuario}/incrementar', 'GamificacaoUsuario\Api\GamificacaoUsuarioController@incrementar')->name('gamificacao.incrementar');

    // Store User
    Route::post('/user/store', 'ApiController@userStore')->name('user.store');

    // Forget User Pass
    Route::post('/user/forget/pass', 'ApiController@userForgetPass')->name('user.forget.pass');


    //Auth
    Route::post('/login', 'ApiController@postLogin')->name('login');

    Route::get('/logout', 'ApiController@logout')->name('logout');


    // Api auth middleware group
    Route::group(['middleware' => 'api.auth'], function () {

        Route::get('/user', 'ApiController@getUser')->name('user');

        Route::post('/user/update', 'ApiController@userUpdate')->name('user.update');
        Route::post('/user/update/image', 'ApiController@userUpdateImage')->name('user.update.image');

        Route::get('/aplicacoes', 'ApiController@getAplicacoes')->name('aplicacoes');

        // Aplicaçao
        Route::get('/aplicacao/{idAplicacao}', 'ApiController@getAplicacao')->name('aplicacao');

        // Play aplicacao
        Route::get('/aplicacao/{idAplicacao}/play', 'ApiController@getAplicacaoPlay')->name('aplicacao-play');


        // User & Instrutor
        Route::prefix('user')->group(function () {
            Route::get('instrutor/{id}', 'User\Api\UserApiController@getInstrutor')->name('user.instrutor.get');
        });


        // Audios
        Route::prefix('audios')->group(function () {
            Route::get('/{filter?}', 'Audio\Api\AudioApiController@listar')->name('audios.listar');
            Route::get('/audio/{idAudio}', 'Audio\Api\AudioApiController@show')->name('audios.show');
        });

        // Instrutores
        Route::prefix('instrutores')->group(function () {
            Route::get('/{filter?}', 'API\InstructorController@index')->name('instructors.listar');
            Route::get('/instrutor/{idInstrutor}', 'API\InstructorController@show')->name('instructors.show');
        });

        // Escolas
        Route::prefix('escolas')->group(function () {
            Route::get('/{filter?}', 'API\EscolaController@index')->name('escolas.listar');
            Route::get('/escola/{idEscola}', 'API\EscolaController@show')->name('escolas.show');
        });

        // Albuns
        Route::prefix('albuns')->group(function () {
            Route::get('/{filter?}', 'Album\Api\AlbumApiController@listar')->name('albuns.listar');
            Route::get('/album/{idAlbum}', 'Album\Api\AlbumApiController@show')->name('albuns.show');
            Route::get('/home/destaques', 'Album\Api\AlbumApiController@destaques')->name('albuns.destaques');
        });

        // Albuns da Escola
        Route::group([
            'prefix' => '{idEscola}'
        ], function () {
            Route::get('/albuns/{filter?}', 'Album\Api\AlbumApiController@listar')->name('albuns.listar');
            Route::get('/albuns/home/destaques', 'Album\Api\AlbumApiController@destaques')->name('albuns.destaques');
        });

        // Playlists
        Route::prefix('playlists')->group(function () {
            Route::get('/', 'Playlist\Api\PlaylistApiController@listar')->name('playlists.listar');
            Route::get('/playlist/{idPlaylist}', 'Playlist\Api\PlaylistApiController@show')->name('playlists.show');
            Route::get('/playlist/destroy/{idPlaylist}', 'Playlist\Api\PlaylistApiController@destroy')->name('playlists.destroy');
            Route::post('/playlist/{idPlaylist}/audio/destroy', 'Playlist\Api\PlaylistApiController@removeOneAudio')->name('playlists.audio.destroy');
            Route::post('/playlist/{idPlaylist}/audio/store', 'Playlist\Api\PlaylistApiController@storeOneAudio')->name('playlists.audio.store');
            Route::post('/criar', 'Playlist\Api\PlaylistApiController@store')->name('playlists.store');
            Route::post('/atualizar/{idPlaylist}', 'Playlist\Api\PlaylistApiController@update')->name('playlists.update');
            Route::post('/audios/atualizar/{idPlaylist}', 'Playlist\Api\PlaylistApiController@updateAudios')->name('playlists.audios.update');
        });

        // Favoritos
        Route::prefix('favoritos')->group(function () {
            Route::get('listar/{field}', 'Favoritos\Api\FavoritosApiController@listar')->name('favoritos.listar');
            Route::post('adicionar', 'Favoritos\Api\FavoritosApiController@store')->name('playlist.store');
            Route::get('/remover/{id}', 'Favoritos\Api\FavoritosApiController@destroy')->name('playlist.destroy');
        });

        // Recentes
        Route::prefix('recentes')->group(function () {
            Route::get('/listar', 'Recentes\Api\RecentesApiController@listar')->name('recentes.listar');
            Route::post('/store', 'Recentes\Api\RecentesApiController@store')->name('recentes.store');
        });

        // Busca
        Route::prefix('busca')->group(function () {
            Route::post('/', 'Busca\Api\BuscaApiController@listar')->name('busca.listar');
        });


        // Badges
        Route::prefix('badges')->group(function () {

            // http://localhost:8000/api/jpiaget/badges/usuario/1/19/desbloquear
            Route::get('usuario/{idUsuario}/{idBadge}/desbloquear', 'Badges\Api\BadgesController@desbloquearUsuarioBadge');

            // http://localhost:8000/api/jpiaget/badges/19/desbloquear
            Route::get('{idBadge}/desbloquear', 'Badges\Api\BadgesController@desbloquearUsuarioAuthBadge');
        });

        // Métricas
        Route::prefix('metricas')->group(function () {

            // http://localhost:8000/api/jpiaget/metricas/nova
            Route::post('nova', 'Metricas\Api\MetricasController@nova');
        });

        // Habilidades
        Route::prefix('habilidades')->group(function () {

            // http://localhost:8000/api/jpiaget/habilidades/usuario/1/2
            Route::post('usuario/{idUsuario}/{idHabilidade}', 'Habilidades\Api\HabilidadesController@UsuarioHabilidade');

            // http://localhost:8000/api/jpiaget/habilidades/2
            Route::post('{idHabilidade}', 'Habilidades\Api\HabilidadesController@UsuarioAuthHabilidade');
        });


        // Gamificação listar xp
        Route::get('gamificacao/usuario/{idUsuario}', 'GamificacaoUsuario\Api\GamificacaoUsuarioController@listar')->name('gamificacao.listar');


        // Api gestão group
        Route::group(['middleware' => 'api.admin'], function () {

            // Gamificação incrementar
            //Route::post('gamificacao/usuario/{idUsuario}/incrementar', 'GamificacaoUsuario\Api\GamificacaoUsuarioController@incrementar')->name('gamificacao.incrementar');
        });
    });


    // Api auth middleware group
    Route::group(['middleware' => 'api.auth'], function () {

        // Retorna usuário logado
        Route::get('/user', 'ApiController@getUser')->name('user');

        Route::get('user/mensagens', 'MensagemController@getMensagens')->name('mensagens');

        Route::get('user/destinatarios', 'MensagemController@getUsuariosConversa')->name('mensagens-destinatarios');

        Route::get('user/mensagens/{idDestinatario}', 'MensagemController@getMensagensTrocadas')->name('mensagens-trocadas');

        Route::post('user/mensagem/enviar', 'MensagemController@postEnviarMensagem')->name('mensagem-enviar');

        // Enviar metrica para usuario logado
        Route::post('/metricas/nova', 'ApiController@postNovaMetrica')->name('metrica-nova');

        // Medalhas
        Route::get('/badges', 'ApiController@getBadges')->name('badges');

        // Medalhas destravadas do usuário logado
        Route::get('/user/badges', 'Api\BadgeController@getUnlockedBadges')->name('badges-destravadas');

        // Destravar medalha - usuário logado
        Route::post('/user/badge/{idBadge}/destravar', 'Api\BadgeController@postUnlockBadge')->name('badge-destravar');

        // Atualiza o progresso do usuário em determinado conteúdo
        Route::post('/user/progresso/{idConteudo}/atualizar', 'ApiController@postProgressoConteudo')->name('progresso-atualizar');

        // Codigo transmissao
        Route::get('/transmissao/{idTransmissao}', 'ApiController@getCodigoTransmissao')->name('codigo-transmissao');

        // Glossario
        Route::get('/glossario/{letra?}', 'ApiController@getGlossario')->name('glossario');

        //Aplicacoes
        Route::get('/aplicacoes', 'ApiController@getAplicacoes')->name('aplicacoes');

        // Aplicaçao
        Route::get('/aplicacao/{idAplicacao}', 'ApiController@getAplicacao')->name('aplicacao');

        // Play aplicacao
        Route::get('/aplicacao/{idAplicacao}/play', 'ApiController@getAplicacaoPlay')->name('aplicacao-play');

        // Conteudos
        Route::get('/conteudos', 'ApiController@getConteudos')->name('conteudos');

        // Conteudo
        Route::get('/conteudo/{idConteudo}', 'ApiController@getConteudo')->name('conteudo');

        // Play Conteudo
        Route::get('/conteudo/{idConteudo}/play', 'ApiController@getConteudoPlay')->name('conteudo-play');

        // Mural turma
        Route::get('/turma/{idTurma}/mural', 'ApiController@getMuralTurma')->name('turma-mural');

        // Mural turma
        Route::post('/turma/{idTurma}/mural/postar', 'ApiController@postMuralTurma')->name('turma-mural-postar');

        // Duvidas professor
        Route::get('professor/{idProfessor}/duvidas', 'ApiController@getDuvidasProfessor')->name('professor-duvidas');


        // Duvida professor
        Route::get('/professor/{idProfessor}/duvida/{idDuvida}', 'ApiController@getDuvidaProfessor')->name('professor-duvida');

        // Avaliacoes professor
        Route::get('/professor/{idProfessor}/avaliacoes', 'ApiController@getAvaliacoesProfessor')->name('professor-avaliacoes');

    });

    // Api admin middleware group
    Route::group(['middleware' => 'api.admin'], function () {

        // Destravar medalha - usuário logado
        Route::post('user/{$idUsuario}/badge/{idBadge}/destravar', 'Api\BadgeController@postUsuarioUnlockBadge')->name('usuario.badge-destravar');

    });

    // Rota de fuga para api nao encontrada
    Route::get('/{page?}', function ($endpoint) {

        return response()->json(["error" => "Endpoint '" . $endpoint . "' não encontrado."]);

    });

    // Rota de fuga para api nao encontrada
    Route::post('/{page?}', function ($endpoint) {

        return response()->json(["error" => "Endpoint '" . $endpoint . "' não encontrado."]);

    });

});
<file_sep>/app/Http/Controllers/ContatoController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

class ContatoController extends Controller
{    
    public function index ()
    {    
        return view('contato');
    }

    public function post ()
    {
        return redirect('/');
    }
}
<file_sep>/database/migrations/2019_08_20_163355_create_configuracoes_gamificacao_table.php
<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateConfiguracoesGamificacaoTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('configuracoes_gamificacao', function (Blueprint $table) {
            $table->increments('id');

            $table->integer('user_id');

            $table->integer('escola_id');

            $table->boolean('login_ativo')->nullable();
            $table->integer('login_xp')->nullable();

            $table->boolean('conclusao_conteudo_ativo')->nullable();
            $table->integer('conclusao_conteudo_xp')->nullable();

            $table->boolean('conclusao_aula_ativo')->nullable();
            $table->integer('conclusao_aula_xp')->nullable();

            $table->boolean('conclusao_curso_ativo')->nullable();
            $table->integer('conclusao_curso_xp')->nullable();

            $table->boolean('conclusao_teste_ativo')->nullable();
            $table->integer('conclusao_teste_xp')->nullable();

            $table->boolean('topico_ativo')->nullable();
			$table->integer('topico_xp')->nullable();

            $table->boolean('comentario_ativo')->nullable();
            $table->integer('comentario_xp')->nullable();

            $table->boolean('level_up_curso_ativo')->nullable();
            $table->integer('level_up_curso')->nullable();

            $table->boolean('level_up_conquista_ativo')->nullable();
            $table->integer('level_up_conquista')->nullable();

            $table->boolean('formula_level_ativo')->nullable();
            $table->string('formula_level')->nullable();

            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('configuracoes_gamificacao');
    }
}
<file_sep>/app/Entities/Glossario/Glossario.php
<?php

namespace App\Entities\Glossario;

use Illuminate\Database\Eloquent\Model;

class Glossario extends Model
{
  protected $table = "glossarios";
  protected $guarded = ['id'];
}
<file_sep>/database/migrations/2019_08_18_132005_add_fields_to_favoritos_table.php
<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class AddFieldsToFavoritosTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('favoritos', function (Blueprint $table) {
            $table->integer('conteudo_id')->nullable();
            $table->integer('album_id')->nullable();
            $table->integer('audio_id')->nullable();
        });
    }




    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('favoritos', function (Blueprint $table) {
            $table->dropColumn('conteudo_id');
            $table->dropColumn('album_id');
            $table->dropColumn('audio_id');
        });
    }
}


<file_sep>/public/assets/js/main.js
"use strict";

//console.log("App url: " + appurl);

function proximoModal(element)
{
    var qtPaginas = $(element).find('.form-page').length;
    // console.log(qtPaginas);

    if(qtPaginas > 1)
    {
        var idPaginaAtual = $(element).find('.form-page:not(.d-none)').attr('id');
        // console.log(idPaginaAtual);

        var paginaAtual = $(element).find('.form-page:not(.d-none)').attr('id').replace("page","");
        // console.log(paginaAtual);

        var preenchido = true;

        $(element).find('#page' + paginaAtual + ' :input[required]').each(function() {
            if( $(this).val() == "")
            {
                $(this).focus();
                preenchido = false;
                return false;
            }
        });

        if(!preenchido)
        {
            console.log("Preencha tudo nesta pagina!");

            swal('Atenção!', "Você deve preencher todos os campos obrigatórios!", "warning");

            return;
        }

        if( $(element).find("#page" + (Number(paginaAtual) + 1)).length >= 1 )
        {
            $(element).find("#" + idPaginaAtual).addClass("d-none");
            $(element).find("#page" + (Number(paginaAtual) + 1)).removeClass("d-none");
        }
        else
        {
            console.log("Não há próxima página. (" + (Number(paginaAtual) + 1) + ")");
        }
    }
    else
    {
        console.log("Sem páginas");
    }
}

function anteriorModal(element)
{
    var qtPaginas = $(element).find('.form-page').length;
    // console.log(qtPaginas);

    if(qtPaginas > 1)
    {
        var idPaginaAtual = $(element).find('.form-page:not(.d-none)').attr('id');
        // console.log(idPaginaAtual);

        var paginaAtual = $(element).find('.form-page:not(.d-none)').attr('id').replace("page","");
        // console.log(paginaAtual);

        if( $(element).find("#page" + (Number(paginaAtual) - 1)).length >= 1 )
        {
            $(element).find("#" + idPaginaAtual).addClass("d-none");
            $(element).find("#page" + (Number(paginaAtual) - 1)).removeClass("d-none");
        }
        else
        {
            console.log("Não há página anterior. (" + (Number(paginaAtual) - 1) + ")");
        }
    }
    else
    {
        console.log("Sem páginas");
    }
}

//Multiple items inputs
function showInputMultiple(element)
{
    $(element).addClass('d-none');
    $(element.parentNode).find("#txtInputMultiple").removeClass('d-none');
    $(element.parentNode).find("#txtInputMultiple").focus();

    // $("#" + element.parentNode.id + " > #divInputAutor").addClass('d-none');
    // $("#" + element.parentNode.id + " > #txtInputAutor").removeClass('d-none');

    // $("#" + element.parentNode.id + " > #txtInputAutor").focus();
}

function endInputMultiple(element)
{
    $(element).addClass('d-none');
    $(element.parentNode).find("#divInputMultiple").removeClass('d-none');

    var inputValue = element.value;

    if(inputValue.indexOf(",") > 0)
    {
        var valores = inputValue.split(', ');

        valores.forEach(val =>
        {
            if(val.indexOf(", ") > 0)
                val = val.replace(", ", "");
            else
                val = val.replace(",", "");

            var novoValor = '<span class="tag-autor mr-2 p-1 px-3">'+
            '<span class="autor-name">' + val + '</span>'+
            '<button type="button" onclick="removerValor(this)" class="btn p-0 m-0 ml-1 text-white bg-transparent"><i class="far fa-times-circle"></i></button>'+
            '</span>';

            $(element.parentNode).find("#divInputMultiple").append( novoValor );
        });
    }
    else
    {
        var novoValor = '<span class="tag-autor mr-2 p-1 px-3">'+
        '<span class="autor-name">' + element.value + '</span>'+
        '<button type="button" onclick="removerValor(this)" class="btn p-0 m-0 ml-1 text-white bg-transparent"><i class="far fa-times-circle"></i></button>'+
        '</span>';

        $(element.parentNode).find("#divInputMultiple").append( novoValor );
    }

    element.value = "";

    AtualizarInputMultiple(element.parentNode);
}

function removerValor(element)
{
    var divMain = element.parentNode.parentNode.parentNode;

    if($(divMain).first().find(".autor-name").length == 1)
    {
        $(divMain).find("#divInputMultiple").addClass('d-none');
        $(divMain).find("#txtInputMultiple").removeClass('d-none');
    }

    $(element.parentNode).remove();

    AtualizarInputMultiple(divMain);

    if (!e) var e = window.event;
    e.cancelBubble = true;
    if (e.stopPropagation) e.stopPropagation();
}

function AtualizarInputMultiple(element)
{
    if($(element).find("#txtResultMultiple").length >= 1)
    {
        $(element).find("#txtResultMultiple").val("");

        var valores = [];

        $(element).find("#divInputMultiple .autor-name").each(function()
        {
            valores.push( $( this ).text() );
        });

        $(element).find("#txtResultMultiple").val( JSON.stringify(valores) )

        console.log($(element).find("#txtResultMultiple").val());

        console.log("Não sumario");
    }
    else if($(element.parentNode.parentNode.parentNode).find("#txtResultSumario").length >= 1 )
    {
        console.log("É sumario");

        var divItensSumario = element.parentNode.parentNode.parentNode;

        $(divItensSumario).find("#txtResultSumario").val();

        var sumario = [];

        $(divItensSumario).find(".item-sumario").each(function(index)
        {
            var autores = [];

            $(this).find(".autores .input-autor .autor-name").each(function(index2)
            {
                autores.push($(this).text());
            });

            var palavras = [];

            $(this).find(".palavras .input-autor .autor-name").each(function(index2)
            {
                palavras.push($(this).text());
            });

            sumario.push({ 'titulo' : $(this).find("#txtTituloItemSumario").val(),
                'autores' : autores,
                'palavras' : palavras,
                'pagina' : $(this).find("#txtPaginaItemSumario").val()
            });
        });

        console.log("Itens do sumário: ", sumario);

        $(divItensSumario).find("#txtResultSumario").val( JSON.stringify(sumario) );

        // console.log( $(divItensSumario).find("#txtResultSumario").val() );
    }

}


function confirmLogout()
{
    swal({
        title: "Saindo",
        text: "Deseja sair da plataforma?",
        icon: "warning",
        buttons: ["Não", "Sim"],
        dangerMode: true,
    })
    .then((willLogout) =>
    {
        if (willLogout)
        {
            if(document.getElementById("logout-form") != null)
            {
                document.getElementById("logout-form").submit();
            }
            else
            {
                console.error('Error: logout-form not found!');
            }
        }
    });
}

function mudouArquivoCapa(input)
{
    // if(input.value.substring(input.value.length - 4).toLowerCase() != ".pdf")
    if(input.accept.toString().indexOf(input.value.substring(input.value.length - 3).toLowerCase()) < 0)
    {
        input.value = null;
        swal('Atenção!', "Selecione um arquivo do tipo correto!", "warning");
    }

    var imgIcon = "";

    if(input.id.indexOf("capa") >= 0)
    {
        imgIcon = '<i class="far fa-image fa-2x text-darkmode mr-2" style="vertical-align:sub;"></i>';
    }

    if(input.value != null && input.value != "")
    {
        $("#" + input.parentNode.id + " #placeholder").addClass('d-none');
        $("#" + input.parentNode.id + " #file-name").html( imgIcon + input.value.split(/(\\|\/)/g).pop() );
        $("#" + input.parentNode.id + " #file-name").removeClass('d-none');
    }
    else
    {
        $(input.parentNode).css('background', '#207adc');
        $("#" + input.parentNode.id + " #placeholder").removeClass('d-none');
        $("#" + input.parentNode.id + " #file-name").addClass('d-none');
    }

    if(input.id.indexOf("capa") >= 0)
    {
        if (input.files &&input.files[0])
        {
            var reader = new FileReader();

            reader.onload = function(e)
            {
                $(input.parentNode).attr('style', 'color:white; background: url(\'' + e.target.result + '\');background-size: contain;background-position: 50% 50%;background-repeat: no-repeat;');
            }

            reader.readAsDataURL(input.files[0]);
        }
    }
}

function mudouArquivoInput(input)
{
    // if(input.accept.toString().indexOf(input.value.substring(input.value.length - 3).toLowerCase()) < 0)
    // {
    //     input.value = null;
    //     swal("Ops!", "Selecione um arquivo do tipo correto!", "warning");
    // }

    if(input.value != null && input.value != "")
    {
        $(input.parentNode).find('.file-name').text( input.value.split(/(\\|\/)/g).pop() );
    }
    else
    {
        $(input.parentNode).find('.file-name').text( "Selecionar arquivo" );
    }
}

function enviouArquivo(input)
{
    if(input.accept.toString().indexOf(input.value.substring(input.value.length - 3).toLowerCase()) < 0)
    {
        input.value = null;
        swal("Ops!", "Selecione um arquivo do tipo correto!", "warning");
    }

    if(input.value != null && input.value != "")
    {
        $(input.parentNode).find('#placeholder').addClass('d-none');
        $(input.parentNode).find('.file-name').removeClass('d-none');
        $(input.parentNode).find('.file-name').text( input.value.split(/(\\|\/)/g).pop() );
    }
    else
    {
        $(input.parentNode).find('.file-name').addClass('d-none');
        $(input.parentNode).find('#placeholder').removeClass('d-none');
    }
}

function excluirNotificacao(id)
{
    $.ajax({
        url: appurl + '/notificacao/' + id + '/excluir',
        type : 'get',
        dataType: 'json',
        success : function(_response) {

                console.log(_response);

                if(_response.success != null)
                {
                    if(id == "todas")
                    {
                        $(".box-notificacao").remove();
                    }
                    else
                    {
                        $("#divNotificacao" + id).remove();
                    }

                    if(parseInt($("#lblQtNotificacoes").text()) > 1)
                    {
                        $("#lblQtNotificacoes").text((parseInt($("#lblQtNotificacoes").text()) - 1));
                    }
                    else
                    {
                        $("#lblQtNotificacoes").addClass('d-none');
                    }

                    if($("#divNotificacoes .dropdown-item").length == 0)
                    {
                        $("#divNotificacoes").append(`<div class="dropdown-item px-4 py-3" style="color: #60748A;min-width:  340px;border-bottom:  2px solid #E3E5F0;">
                            Você não possui notificações.
                        </div>`);
                    }
                }
        },
        error : (err) =>
        {
            console.log(err);
        }
    });
}

function toggleSideMenu()
{
    // if($("#divSideMenu").length > 0)
    // {
    //     console.log($("#divSideMenu").css("width"));
    //     if($("#divSideMenu").css("margin-left") != "0px")
    //     {
    //         $("#divMainMenu").css("max-width", "calc(100% - " + $("#divSideMenu").css("width") + ")");
    //         setTimeout(() => {
    //             $("#divSideMenu").css("margin-left", "0px");
    //         }, 100);
    //     }
    //     else
    //     {
    //         $("#divSideMenu").css("margin-left", "-" + $("#divSideMenu").css("width"));
    //         setTimeout(() => {
    //             $("#divMainMenu").css("max-width", "100%");
    //         }, 100);
    //     }
    // }

    if($(".sidebar").hasClass("show"))
    {
        $(".sidebar").removeClass("show");
    }
    else
    {
        $(".sidebar").addClass("show");
    }
}

function mostrarBarraPesquisa()
{
    if($(".navbar #txtPesquisaPrincipal").hasClass('d-none'))
    {
        $(".navbar #txtPesquisaPrincipal").removeClass('d-none');
    }
    else
    {
        $(".navbar #txtPesquisaPrincipal").addClass('d-none');

        $(".navbar #formPesquisar").submit();
    }
}

function findValueWhere(_array, _match, _needle)
{
    // iterate over each element in the array
    for (var i = 0; i < _array.length; i++)
    {
        if (_array[i][_match] == _needle)
        {
            return _array[i];
        }
    }
}

function showCodigoAula()
{
    if(!$(".sidebar").hasClass('show'))
    {
        toggleSideMenu();
    }

    $(".sidebar #lblInserirCodigoAula").addClass('d-none');

    $(".sidebar #formInserirCodigoAula").removeClass('d-none');

    $(".sidebar [name='codigo']").focus();
}
<file_sep>/app/Entities/Audio/Audio.php
<?php

namespace App\Entities\Audio;

use App\Entities\Album\Album;
use App\Entities\Playlist\Playlist;
use App\Entities\AudioInteracoes\AudioInteracoes;
use App\User;
use Illuminate\Database\Eloquent\Model;

class Audio extends Model
{
    protected $table = "audios";
    protected $hidden = ['pivot'];

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'categoria_id',
        'titulo',
        'descricao',
        'file',
        'duracao'
    ];




    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }




    public function albuns()
    {
        return $this->belongsToMany(Album::class, 'album_audios', 'audio_id');
    }




    public function playlists()
    {
        return $this->belongsToMany(Playlist::class, 'playlist_audios', 'audio_id');
    }




    public function interacoes()
    {
        return $this->hasMany(AudioInteracoes::class, 'audio_id')
            ->orderBy('inicio', 'ASC');
    }




    public function getIdAttribute($value)
    {
        return "$value";
    }




    public function getUrlAttribute()
    {
        $path = env("APP_URL") . '/uploads/audios/user_id_' . $this->attributes['artist'] . '/' . $this->attributes['url'];
        return $path;
    }




    public function getDurationAttribute()
    {
        $duracao = $this->attributes['duration'];
        sscanf($duracao, "%d:%d:%d", $hours, $minutes, $seconds);
        $durationSeconds = isset($hours) ? $hours * 3600 + $minutes * 60 + $seconds : $minutes * 60 + $seconds;
        return $durationSeconds;
    }




    public function getArtistAttribute()
    {
        $user = User::where('id', $this->attributes['artist'])->select('name')->first();
        return $user->name;
    }

}
<file_sep>/app/Generals/Presenter/Questoes/QuestoesPresenter.php
<?php


namespace App\Generals\Presenter\Questoes;


use Laracasts\Presenter\Presenter;

class QuestoesPresenter extends Presenter
{
    public function questoesTipo()
    {
        if ($this->tipo === 1) {
            return 'Dissertativa';
        }

        if($this->tipo === 2){
            return 'Múltipla escolha';
        }

        return 'Nenhum tipo encontrado';
    }
}
<file_sep>/app/Http/Controllers/Exportacao/ExportacaoController.php
<?php
namespace App\Http\Controllers\Exportacao;

class ExportacaoController
{

    public function tirarAcentos($string)
    {
        return preg_replace(array("/(á|à|ã|â|ä)/","/(Á|À|Ã|Â|Ä)/","/(é|è|ê|ë)/","/(É|È|Ê|Ë)/","/(í|ì|î|ï)/","/(Í|Ì|Î|Ï)/","/(ó|ò|õ|ô|ö)/","/(Ó|Ò|Õ|Ô|Ö)/","/(ú|ù|û|ü)/","/(Ú|Ù|Û|Ü)/","/(ñ)/","/(Ñ)/"),explode(" ","a A e E i I o O u U n N"),$string);
    }    

    public function generateFileName($prefix, $string, $extension = '')
    {
        $fileName = $prefix . '_' . mb_strtolower($this->tirarAcentos(str_replace(' ', '_', $string))) . '.' . $extension;
        return $fileName;
    }
    
    public function callDownloadFromStream($content, $fileName, $contentType = '')
    {
        ob_start();

        if(!$contentType || empty($contentType))
        {
            $headers = ['Content-Type: application/json; charset=utf-8'];
        }

        echo $content;

        return response()->streamDownload(function() 
        {    
            $bufferstr = ob_get_contents();
        }, $fileName, $headers);

        ob_end_clean();        
    }

}<file_sep>/app/Http/Controllers/BaseController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

class BaseController extends Controller
{    
    public function index()
    {
        return 'base';
    }
}<file_sep>/app/Http/Controllers/Badges/Api/BadgesController.php
<?php

namespace App\Http\Controllers\Badges\Api;

use App\Entities\BadgeUsuario\Api\Repository as BadgeUsuario;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class BadgesController extends Controller
{
  
  private $badgeUsuario;
  
  public function __construct(BadgeUsuario $badgeUsuario)
  {
    $this->badgeUsuario = $badgeUsuario;
  }
  
  public function desbloquearUsuarioBadge($idUsuario, $idBadge)
  {
    try {
      $this->badgeUsuario->store(['user_id' => $idUsuario, 'badge_id' => $idBadge]);
      return response()->json(["success" => "Medalha desbloqueada com sucesso!"]);
    } catch (\Exception $exception) {
      return response()->json(["error" => "Erro ao desbloquear medalha", "message:" => $exception->getMessage()]);
    }
  }
  
  public function desbloquearUsuarioAuthBadge($idBadge)
  {
    if ($this->badgeUsuario->store(['user_id' => Auth::user()->id, 'badge_id' => $idBadge])) {
      return response()->json(["success" => "Medalha desbloqueada com sucesso!"]);
    }
    return response()->json(["error" => "Erro ao desbloquear medalha"]);
  }
}
<file_sep>/app/Entities/AudioInteracoes/AudioInteracoes.php
<?php

namespace App\Entities\AudioInteracoes;

use App\Entities\Audio\Audio;
use App\User;
use Illuminate\Database\Eloquent\Model;

class AudioInteracoes extends Model
{
    protected $table = "audios_interacoes";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'audio_id',
        'titulo',
        'descricao',
        'inicio',
        'fim'
    ];



    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }



    public function interacao()
    {
        return $this->belongsTo(Audio::class, 'audio_id');
    }

}
<file_sep>/app/Entities/Questoes/Questoes.php
<?php

namespace App\Entities\Questoes;

use App\Entities\TesteNivelamento\TesteNivelamentoQuestao;
use App\Generals\Presenter\Questoes\QuestoesPresenter;
use Illuminate\Database\Eloquent\Model;
use Laracasts\Presenter\PresentableTrait;

class Questoes extends Model
{
    // tipo == 1 é dissertativa
    // tipo == 2 multipla escolha

    use PresentableTrait;
    protected $presenter = QuestoesPresenter::class;

    protected $table = "questoes";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'titulo',
        'descricao',
        'tipo',
        'alternativas',
        'resposta_correta'
    ];


}
<file_sep>/app/Http/Controllers/HomeController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\User;
use App\Conteudo;
use App\Metrica;
use App\Turma;
use App\AlunoTurma;

class HomeController extends Controller
{
    public function index()
    {
        return redirect()->route('home');
    }

    public function home()
    {
        if(Metrica::where([['user_id', '=', Auth::user()->id], ['titulo', 'like', 'Jogar aplicação%']])->first() != null)
        {
            $idUltimaAplicacao = str_replace('Jogar aplicação - ', "", Metrica::where([['user_id', '=', Auth::user()->id], ['titulo', 'like', 'Jogar aplicação - %']])->first()->titulo);
        }
        else
        {
            $idUltimaAplicacao = 0;
        }

        if(AlunoTurma::where('user_id', '=', Auth::user()->id)->first() != null)
        {
            $idTurma = AlunoTurma::where('user_id', '=', Auth::user()->id)->first()->turma_id;
        }
        else
        {
            $idTurma = 0;
        }

        if(Turma::find($idTurma) != null)
        {
            $idProfessor = Turma::find($idTurma)->user_id;
        }
        else
        {
            $idProfessor = 0;
        }

        return view('home')->with( compact('idUltimaAplicacao', 'idTurma', 'idProfessor') );
    }

    public function entrar()
    {
        if(\Auth::check())
        {
            return redirect()->route('catalogo');
        }
        else
        {
            return view('auth.login');
        }
    }

    public function registrar()
    {
        if(\Auth::check())
        {
            return redirect()->route('catalogo');
        }
        else
        {
            return view('auth.register');
        }

    }
}
<file_sep>/app/Http/Controllers/API/AudioPlaylistController.php
<?php

namespace App\Http\Controllers\API;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class AudioPlaylistController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request, $idPlaylist, $idAudio)
    {
      $user = JWTAuth::toUser();

      try {
        $playlist = Playlist::where("user_id", $user->id)->find($idPlaylist);
        $playlist->audios()->attach($idAudio);
        return response()->json(["message" => "Playlist atualizada com sucesso!"]);
      } catch (\Exception $exception) {
          return response()->json(["error" => $exception->getMessage()], 500);
      }
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        //
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $idPlaylist, $idAudio)
    {
      $user = JWTAuth::toUser();

      $validate = Validator::make($request->all(), [
        "audio_id" => ["required"],
      ], [
          "audio_id.required" => "Selecione pelo menos 1 áudio em sua playlist."
      ]);

      if ($validate->fails())
        return response()->json(["error" => $validate->errors()]);

      try {
          $playlist = Playlist::where("user_id", $user->id)->find($idPlaylist);
          $playlist->audios()->sync($idAudio);
          return response()->json(["message" => "Playlist atualizada com sucesso!"]);
      } catch (\Exception $exception) {
          return response()->json(["error" => $exception->getMessage()], 500);
      }
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($idPlaylist, $idAudio)
    {
      $user = JWTAuth::toUser();

      try {
        $playlist = Playlist::where("user_id", $user->id)->find($idPlaylist);
        $playlist->audios()->detach($idAudio);
        return response()->json("Playlist atualizada com sucesso!");
      } catch (\Exception $exception) {
          return response()->json(["error" => $exception->getMessage()], 500);
      }
    }
}
<file_sep>/database/migrations/2019_08_08_111945_create_escolas_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateEscolasTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('escolas', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('user_id');
			$table->string('titulo');
			$table->text('descricao');
			$table->string('capa');
			$table->boolean('postagem_aberta')->nullable();
			$table->integer('limite_alunos');
			$table->string('nome_completo')->nullable();
			$table->string('cnpj')->nullable();
			$table->string('nome_responsavel')->nullable();
			$table->string('email_responsavel')->nullable();
			$table->string('telefone_responsavel')->nullable();
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('escolas');
	}

}
<file_sep>/app/Http/Controllers/Habilidades/Admin/HabilidadesController.php
<?php

namespace App\Http\Controllers\Habilidades\Admin;


use App\Entities\Habilidade\Habilidade;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class HabilidadesController extends Controller
{
    private $habilidade;

    public function __construct(Habilidade $habilidade)
    {
        $this->habilidade = $habilidade;
    }

    public function index()
    {

        $habilidades = Habilidade::orderBy('id', 'DESC')->get();
        $categorias = Habilidade::all()->pluck('categoria')->unique()->toArray();
        return view('pages.habilidades.admin.index', compact('habilidades', 'categorias'));
    }

    public function store(Request $request)
    {
        $this->validate($request, [
            'titulo'    => 'required',
            'categoria' => 'required'
        ]);
        $values = $request->all();
        $values['user_id'] = Auth::user()->id;

        Habilidade::create($values);
        return redirect()->route('gestao.habilidades.listar')->with('message', 'Habilidade cadastrada com sucesso!');
    }


    public function update($id, Request $request)
    {
        $this->validate($request, [
            'titulo'    => 'required',
            'categoria' => 'required'
        ]);
        $values = $request->all();
        Habilidade::find($id)->update($values);
        return redirect()->route('gestao.habilidades.listar')->with('message', 'Habilidade atualizada com sucesso!');
    }


    public function delete(Request $request)
    {
        Habilidade::find($request->idHabilidade)->delete();
        return redirect()->route('gestao.habilidades.listar')->with('message', 'Habilidade excluída com sucesso!');
    }

}
<file_sep>/app/Http/Controllers/TopicoCursoController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\User;
use App\Metrica;

use App\Curso;
use App\TopicoCurso;
use App\ComentarioTopicoCurso;

use App\AvaliacaoInstrutor;

class TopicoCursoController extends Controller
{
    public function index($curso_id)
    {
        $curso = Curso::with('escola')->find($curso_id);

        if($curso == null)
        {
            return redirect()->back()->withErrors("Curso não encontrado!");
        }

        if(AvaliacaoInstrutor::where('instrutor_id', '=', $topico->user->id)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $topico->user->id)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $topicos = TopicoCurso::where([['curso_id', '=', $curso_id]])
        ->orderBy('status', 'asc')
        ->orderBy('created_at', 'desc')
        ->get();
        // ->sortBy('status');

        foreach ($topicos as $topico)
        {
            $topico->qt_comentarios = ComentarioTopicoCurso::where([['topico_curso_id', '=', $topico->id]])->count();
        }

        // dd($topicos);

        return view('curso.topicos')->with(compact('topicos', 'curso', 'avaliacaoInstrutor'));
    }

    public function postNovoTopico($curso_id, Request $request)
    {
        if(Curso::find($curso_id) == null)
        {
            Redirect::back()->withErrors(['Curso não encontrado!']);
        }
        else if(Curso::find($curso_id)->user_id != Auth::user()->id && (strtoupper(Auth::user()->permissao) != "P" && strtoupper(Auth::user()->permissao) != "G" && strtoupper(Auth::user()->permissao) != "Z"))
        {
            Redirect::back()->withErrors(['Você não tem permissão para realizar esta ação!']);
        }
        else
        {
            $topico = TopicoCurso::create([
                'curso_id' => $curso_id,
                'user_id' => Auth::user()->id,
                'titulo' => $request->titulo,
                'descricao' => $request->descricao
            ]);

            return Redirect::back()->with('message', 'Tópico enviada com sucesso!');
        }
    }

    public function topico($curso_id, $topico_curso_id)
    {
        $topico = TopicoCurso::with('curso', 'user', 'comentarios')->has('curso')->has('user')->find($topico_curso_id);

        // dd($topico);

        if($topico == null)
        {
            return redirect()->route('curso', $curso_id)->withErrors("Tópico não encontrado!");
        }

        if(AvaliacaoInstrutor::where('instrutor_id', '=', $topico->user->id)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $topico->user->id)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $curso = Curso::find($curso_id);

        Metrica::create([
            'user_id' => Auth::check() ? Auth::user()->id : 0,
            'titulo' => 'Visualização tópico - ' . $topico->id
        ]);

        $topico->visualizacoes = Metrica::where('titulo', '=', 'Visualização tópico - ' . $topico->id)->pluck('user_id')->unique('user_id')->count();

        return view('curso.topico')->with(compact('curso', 'topico', 'avaliacaoInstrutor'));
    }

    public function postAtualizarTopico($curso_id, $topico_curso_id, Request $request)
    {
        // dd($topico_curso_id);

        if(TopicoCurso::find($topico_curso_id) == null)
        {
            return Redirect::back()->withErrors(['Tópico não encontrado!']);
        }
        else
        {
            TopicoCurso::find($topico_curso_id)->update([
                'status' => $request->status
            ]);

            return Redirect::back()->with('message', 'Tópico atualizado com sucesso!');
        }
    }

    public function postExcluirTopico($curso_id, $topico_curso_id)
    {
        if(TopicoCurso::find($topico_curso_id) == null)
        {
            return Redirect::back()->withErrors(['Tópico não encontrado!']);
        }
        else
        {
            TopicoCurso::find($topico_curso_id)->delete();

            return Redirect::back()->with('message', 'Tópico excluída com sucesso!');
        }
    }

    public function postEnviarComentarioTopico($curso_id, $topico_curso_id, Request $request)
    {
        if(TopicoCurso::find($topico_curso_id) == null)
        {
            Redirect::back()->withErrors(['Tópico não encontrado!']);
        }
        else
        {
            $comentario = ComentarioTopicoCurso::create([
                'topico_curso_id' => $topico_curso_id,
                'user_id' => Auth::user()->id,
                'conteudo' => $request->conteudo
            ]);

            return Redirect::back();//->with('message', 'Comentário enviado com sucesso!');
        }
    }

    public function postExcluirComentarioTopico($curso_id, $topico_curso_id, $comentario_id)
    {
        if(ComentarioTopicoCurso::find($comentario_id) == null)
        {
            return Redirect::back()->withErrors(['Comentário não encontrado!']);
        }
        else
        {
            ComentarioTopicoCurso::find($comentario_id)->delete();

            return Redirect::back();//->with('message', 'Comentário excluído com sucesso!');
        }
    }
}
<file_sep>/app/CodigoAcessoEscola.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class CodigoAcessoEscola extends Model
{
    protected $table = 'codigo_acesso_escola';

    //Preenchiveis
    protected $fillable = [
        'escola_id',
        'turma_id',
        'codigo',
        'aluno_id',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [

    ];

    public function escola()
    {
        return $this->belongsTo('App\Escola');
    }

    public function turma()
    {
        return $this->belongsTo('App\Turma');
    }

    public function aluno()
    {
        return $this->belongsTo('App\User', 'aluno_id');
    }

}
<file_sep>/app/Http/Controllers/API/LoginController.php
<?php

namespace App\Http\Controllers\API;

use App\User;
use App\Lib\Format;
use App\Entities\GamificacaoUsuario\GamificacaoUsuario;
use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Lang;
use Illuminate\Support\Facades\Mail;
use Tymon\JWTAuth\Exceptions\JWTException;
use Tymon\JWTAuth\Facades\JWTAuth;

class LoginController extends Controller
{
    public function login(Request $request)
    {
        try {
            $credentials = array(
                "email"    => $request->data["email"],
                "password" => $request->data["password"],
            );

            try {
                $token = JWTAuth::attempt($credentials);
            } catch (JWTException $ex) {
                return response()->json(["error" => Lang::get("messages.error_generate_token")], 500);
            }

            if (!$token) {
                return response()->json(["error" => Lang::get("messages.invalid_credentials")], 401);
            }

            $user = JWTAuth::toUser($token);

            $GamificacaoUsuario = new GamificacaoUsuario();
            $xp = GamificacaoUsuario::select('xp')->where('user_id', $user->id)->first()["xp"];

            $user["xp"] = $xp;
            $user["level"] = $GamificacaoUsuario->getLevel($xp);

            return [
                "access_token" => $token,
                "token_type" => "bearer",
                "expires" => config("jwt.ttl"),
                "user" => $user,
            ];
        } catch (\Exception $e) {
            return response(["message" => $e->getMessage()], 500);
        }
    }

    public function refresh()
    {
        try {
            if ($token = JWTAuth::getToken()) {
                return [
                    "access_token" => JWTAuth::refresh($token),
                    "token_type" => "bearer",
                    "expires" => config("jwt.ttl")
                ];
            }
        } catch (JWTException $e) {
            return response(["message" => $e->getMessage()], 500);
        }

        return response(Lang::get("messages.request_without_token"), 401);
    }

    public function forgotPassword(Request $request){

      $data = collect($request->data);

      if (!$data->has("email"))
        return response(["message" => "Email não informado"], 500);

      $user = User::where("email", $data["email"])->get();

      if (!count($user))
       return response(["message" => "Email não encontrado"], 500);

      try
      {
        $user = $user->first();
        $user->remember_token = Hash::make(env("APP_KEY"));
        $user->save();

        $data = [
          "email" => $data["email"],
          "name"  => $user->name,
          "token" => md5(uniqid(time(), true))
        ];


        Mail::send("mail.reset-email", $data, function ($message) use ($data) {
          $message->from("<EMAIL>", "Suporte <NAME>");

          $message->to($data["email"], $data["name"])->subject("<NAME> - Link para resetar senha");
        });



        return response(["message" => "Email enviado com sucesso. Verifique seu email para resetar sua senha"], 200);
      }
      catch (\Exception $e)
      {
        return response(["message" => $e->getMessage()], 500);
      }


    }

    public function logout(Request $request)
    {
        try {
            $token = $request->get("token");
            JWTAuth::invalidate($token);
            return ["message" => Lang::get("messages.logout_success")];
        } catch (JWTException $e) {
            return response(["message" => Lang::get("messages.logout_error")], 500);
        }
    }
}
<file_sep>/app/Http/Controllers/CategoriaController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Redirect;
use Session;

use App\Categoria;

class CategoriaController extends Controller
{
    public function index()
    {
        return 'base';
    }

    public function categorias()
    {

        if(Input::get('qt') == null)
            $amount = 10;
        else
            $amount = Input::get('qt');


        if(Input::get('pesquisa') != null)
            $pesquisa = Input::get('pesquisa');

        if(isset($pesquisa))
        {
            $categorias = Categoria::where('id', 'like', '%' . $pesquisa . '%')->
                orWhere('titulo', 'like', '%' . $pesquisa . '%')->
                paginate($amount);
        }
        else
        {
            $categorias = Categoria::paginate($amount);
        }

        // dd($categorias);

        return view('dashboard.categorias')->with(compact('categorias', 'amount'));

    }

    public function postNova(Request $request)
    {

        // dd(Categoria::where('titulo', '=', $request->titulo)->first());

        if(Categoria::where('titulo', '=', $request->titulo)->first() != null)
        {
            \Session::flash('error', '!Categoria já existente!');
        }
        else
        {
            Categoria::create([
                'user_id' => \Auth::user()->id,
                'titulo' => mb_strtolower($request->titulo, 'utf-8'),
                'tipo' => $request->tipo,
            ]);

            \Session::flash('success', 'Categoria criada com sucesso!');
        }

        return redirect()->route('gestao.categorias');

    }

    public function postUpdate(Request $request)
    {

        if(Categoria::find($request->id) != null)
        {
            Categoria::find($request->id)->update([
                'titulo' => mb_strtolower($request->titulo, 'utf-8'),
                'tipo' => $request->tipo,
            ]);

            return Redirect::back()->with('message', 'Categoria atualizada com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Categoria não encontrada!']);
        }

    }

    public function getCategoria($idCategoria)
    {
        if(Categoria::find($idCategoria) != null)
        {
            $categoria = Categoria::find($idCategoria);

            return response()->json(["response" => true, 'data' => 'Categoria encontrada com sucesso!', 'categoria' => $categoria]);
        }
        else
        {
            return response()->json(["response" => false, 'data' => 'Categoria não encontrada!']);
        }

    }

    public function deletar($idCategoria)
    {
        if( strrpos(mb_strtoupper(\Auth::user()->permissao, 'UTF-8'), "Z") === false)
        {
            return response()->json(['error' => 'Você não tem permissão para deletar este item, consulte o administrador!']);
        }

        if(Categoria::find($idCategoria) != null)
        {
            if(mb_strtolower(Categoria::find($idCategoria)->titulo, 'utf-8') != "geral")
            {
                $categoria = Categoria::find($idCategoria);

                $categoria->delete();

                return response()->json(['success' => 'Categoria deletada com sucesso!']);
            }
            else
            {
                return response()->json(['error' => 'Você não pode deletar a categorial Geral!']);
            }
        }
        else
        {
            return response()->json(['error' => 'Categoria não encontrada!']);
        }

    }
}
<file_sep>/database/migrations/2019_08_08_111945_create_avaliacoes_escola_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateAvaliacoesEscolaTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('avaliacoes_escola', function(Blueprint $table)
		{
			$table->integer('user_id');
			$table->integer('escola_id');
			$table->text('descricao');
			$table->float('avaliacao', 10, 0);
			$table->timestamps();
			$table->primary(['user_id','escola_id']);
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('avaliacoes_escola');
	}

}
<file_sep>/app/Entities/Habilidade/Habilidade.php
<?php

namespace App\Entities\Habilidade;

use App\Entities\HabilidadeUsuario\HabilidadeUsuario;
use App\User;
use Illuminate\Database\Eloquent\Model;

class Habilidade extends Model
{
  
  protected $table = 'habilidades';
  
  //Preenchiveis
  protected $fillable = [
    'user_id',
    'titulo',
    'visibilidade',
    'categoria'
  ];
  
  // Protegidos
  protected $hidden = [
  ];
  
  //Padrões
  protected $attributes = [
    'visibilidade' => 1,
  ];
  
  public function user()
  {
    return $this->belongsTo(User::class, 'user_id');
  }
  
  public function habilidade_usuario()
  {
    return $this->belongsTo(Habilidade::class);
  }
  
  public function minhas()
  {
    return $this;
  }
}
<file_sep>/resources/lang/en/messages.php
<?php

return [
    'invalid_credentials' => 'Login ou Senha inválidos',
    'error_generate_token' => 'Não foi possível criar o token',
    'generic_error' => 'Erro inesperado. Contacte o administrador',
    'request_without_token' => 'Token não fornecido',
    'logout_success' => 'Logout efetuado com sucesso',
    'logout_error' => 'Erro ao efetuar o logout',
    'mensagem_cadastro' => ':nome salv:artigo com sucesso',
    'mensagem_erro_padrao' => 'Erro ao tentar efetuar a operação. Tente novamente',
    'mensagem_removido' => ':nome removid:artigo com sucesso',
    'mensagem_atualizado' => ':nome atualizad:artigo com sucesso',
    'validacao_required' => 'Preencha o campo :nome',
    'validacao_integer' => 'Preencha o campo :nome',
    'validacao_numeric' => 'O campo :nome deve conter apenas números',
    'validacao_email' => 'O e-mail informado é invalido',
    'validacao_unique' => 'Este :nome já foi cadastrado',
    'validacao_mimes' => 'Apenas formatos :nome são validos',
    'validacao_cpf_invalido' => 'CPF inválido',
    'validacao_max' => 'O limite para upload de arquivo é de '.env('LIMITE_TAMANHO_UPLOAD'),
    'validacao_gte' => 'O campo :nome deve ser maior ou igual que :value',
    'validacao_cpf_formato_invalido' => 'O CPF deve ser no formato xxx.xxx.xxx-xx',
    'validacao_cnpj_invalido' => 'CNPJ inválido',
    'validacao_cnpj_formato_invalido' => 'O CNPJ deve ser no formato xx.xxx.xxx/xxxx-xx',
    'template' => 'template',
];
<file_sep>/app/Entities/GamificacaoUsuario/GamificacaoUsuario.php
<?php

namespace App\Entities\GamificacaoUsuario;

use App\User;
use Illuminate\Database\Eloquent\Model;

class GamificacaoUsuario extends Model
{
    protected $table = "gamificacao_usuario";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'xp',
        'notificado_level_up',
    ];

    protected $attributes = [
        'notificado_level_up' => true,
    ];

    protected $casts = [
        'notificado_level_up' => 'boolean',
    ];

    //
    // Relationships
    //
    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }

    public function user_escola()
    {
        return $this->belongsTo(User::class, 'user_id')->with('escola');
    }

    //
    // Mutators
    //
    public function getXpResetedAttribute()
    {
        $xp = $this->xp - $this->level_xp( $this->level_atual() );

        return $xp;
    }

    // Game & Level Design functions

    // Ajustar de acordo com a dificuldade para passar de nível
    protected $xp_variable = 50;

    public function level_atual()
    {
        return $this->getLevel($this->xp) ;
    }

    public function level_xp($lvl)
    {
        $level_xp = $this->xp_variable * $lvl * $lvl - $this->xp_variable * $lvl;

        return $level_xp;
    }


    public function next_level_xp($reseted = false)
    {
        if(!$reseted)
        {
            $next_level = $this->getLevel($this->xp) + 1;

            $next_level_xp = $this->xp_variable * $next_level * $next_level - $this->xp_variable * $next_level;

        }
        else
        {
            $previous_level_xp = $this->level_xp( $this->level_atual() );

            $next_level_xp = $this->next_level_xp() - $previous_level_xp;
        }

        return $next_level_xp;
    }

    public function next_level_progress($reseted = false)
    {
        if($this->xp == 0)
        {
            return 0;
        }

        if(!$reseted)
        {
            $percentual = (($this->xp * 100) / $this->next_level_xp());
        }
        else
        {
            $percentual = (($this->xp_reseted * 100) / $this->next_level_xp(true));
        }

        return $percentual;
    }

    public function getLevel($amount_xp)
    {
        $level = ($this->xp_variable + sqrt($this->xp_variable * $this->xp_variable - 4 * $this->xp_variable * (- $amount_xp ) ))/ (2 * $this->xp_variable);
        // $level = (25 + sqrt(625 + 100 * $this->xp)) / 50;

        // return ($level);
        return floor($level);
    }

}
<file_sep>/app/Generals/Presenter/Conteudos/ConteudoPresenter.php
<?php


namespace App\Generals\Presenter\Conteudos;


use Laracasts\Presenter\Presenter;

class ConteudoPresenter extends Presenter
{

    public function conteudoTipo()
    {
        if ($this->tipo === 1) {
            return 'Misto';
        }

        if ($this->tipo === 2) {
            return 'Áudio';
        }

        if ($this->tipo === 3) {
            return 'Vídeo';
        }

        if ($this->tipo === 4) {
            return 'Slide';
        }

        if ($this->tipo === 5) {
            return 'Transmissão';
        }

        if ($this->tipo === 6) {
            return 'Upload';
        }

        if ($this->tipo === 7) {
            return 'Dissertativa';
        }

        if ($this->tipo === 8) {
            return 'Quiz';
        }

        if ($this->tipo === 9) {
            return 'Prova';
        }

        if ($this->tipo === 10) {
            return 'Entregável';
        }

        if ($this->tipo === 11) {
            return 'Livro digital';
        }

        return 'nenhum tipo encontrado';
    }
}
<file_sep>/app/Console/Kernel.php
<?php

namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    /**
     * The Artisan commands provided by your application.
     *
     * @var array
     */
    protected $commands = [
        //
    ];

    /**
     * Define the application's command schedule.
     *
     * @param  \Illuminate\Console\Scheduling\Schedule  $schedule
     * @return void
     */
    protected function schedule(Schedule $schedule)
    {
        // $schedule->command('inspire')
        //          ->hourly();


        // $schedule->call(function () {

        //     \Mail::send([], [], function($message) {


        //         $message
        //         ->from('<EMAIL>', '<NAME>')
        //         ->to('<EMAIL>')
        //         ->subject('Automatic Testing mails - ' . date("H:i d/m/Y"))
        //         // ->setBody('<h1>Hi, welcome user!</h1>', 'text/html'); // for HTML rich messages
        //         ->setBody('Apenas um e-mail de teste que deve ser enviado de tempos em tempos automáticamente!'); // assuming text/plain

        //     });

        // })
        // // ->everyMinute();
        // ->everyFiveMinutes();
        // // ->withoutOverlapping(); //So funciona se tiver name na schedule

        // $schedule->command('email.example:cron')->everyFiveMinutes();

    }

    /**
     * Register the commands for the application.
     *
     * @return void
     */
    protected function commands()
    {
        $this->load(__DIR__.'/Commands');

        require base_path('routes/console.php');
    }
}
<file_sep>/app/Entities/Questoes/Repository.php
<?php

namespace App\Entities\Questoes;


class Repository
{
    private $questoes;
    
    public function __construct(Questoes $questoes)
    {
        $this->questoes = $questoes;
    }
    
    public function all()
    {
        return $this->questoes->orderBy('id', 'DESC')->get();
    }
    
    public function store($values)
    {
        return $this->questoes->create($values);
    }
    
    public function update($id, $values)
    {
        return $this->questoes->find($id)->update($values);
    }
    
    public function delete($id)
    {
        return $this->questoes->find($id)->delete();
    }
    
    public function select()
    {
        return $this->questoes->select('titulo', 'id')->get();
    }
    
    public function find($id)
    {
        return $this->questoes->find($id);
    }
    
}
<file_sep>/resources/js/pages/roteiros/admin/indexRoteiros.js
var countCreateTopico = 0;

$('.bt-adicionar-topico').on('click', function() {

    if($(this).closest('form').find('.checkbox-topico').length) {
        countCreateTopico = $(this).closest('form').find('.checkbox-topico').length ;
    }

    var myHTML = '';
    var myHTML = myHTML + '<div class="container-input">';
    var myHTML = myHTML + ' <input class="form-check-input checkbox-topico" type="checkbox" name="topico['+countCreateTopico+'][status]" value="0" checked>';
    var myHTML = myHTML + ' <input type="text" class="form-control input-topico" name="topico['+countCreateTopico+'][titulo]" placeholder="Tópico" required="">';
    var myHTML = myHTML + ' <button type="button" class="bt-excluir-topico btn btn-light bg-white box-shadow text-declined"><i class="fas fa-trash"></i></button>';
    var myHTML = myHTML + '</div>';

    $(this).closest('form').find('.container-input-topico').append(myHTML);

    var heightTopicos = $(this).closest('form').find('.col-topicos')[0].scrollHeight;
    $('.col-topicos').animate({ scrollTop: heightTopicos }, 500);

    countCreateTopico = (countCreateTopico+1);
});

$('.col-topicos').on('click', '.checkbox-topico', function() {
    if($(this).val() == 1) {
        $(this).val(0);
    } else {
        $(this).val(1);
    }
});

$('.col-topicos').on('click', '.bt-excluir-topico', function() {
    $(this).parent().remove();
});

$('.lb-percent').each(function() {
    $(this).next().children().css('width', $(this).text());
});

window.ajaxUpdateStatusTopico = function(id) {
    var obj = $('#topico_'+id);

    if(obj.val() == 1) {
        obj.val(0);
        var tempCheckboxValue = 0;
    } else {
        obj.val(1);
        var tempCheckboxValue = 1;
    }

    $.ajax({
        headers: { 'X-CSRF-TOKEN': $('input[name="_token"]').val() },
        type: "POST",
        dataType: 'text',
        data: {
            'id': id,
            'status': obj.val()
        },
        url: "roteiros/updateStatusTopico",
        success: function(response) {
            var roteiroID = obj.data('roteiro-id');
            var cardRoteiro = $('#cardRoteiro_' + roteiroID);
            var editModal = $('#divModalEditRoteiro_' + roteiroID);
            var viewModal = $('#divModalViewRoteiro_' + roteiroID);

            var topicosAtivos = viewModal.find('input:checkbox:checked').length;
            var totalTopicos = viewModal.find('input:checkbox').length;
            var topicosInativos = viewModal.find('input:checkbox:not(":checked")').length;

            console.log('topicosAtivos: ' + topicosAtivos);
            console.log('totalTopicos: ' + totalTopicos);
            console.log('topicosInativos: ' + topicosInativos);

            if(topicosInativos == totalTopicos) {
                topicosInativos = 0;
            }

            if(topicosAtivos == 0) {
                //0%
                viewModal.find('.fill-percent-bg').css('width', '0%');
                var resultPorcentagemTopicos = '0';
            }

            if( (topicosAtivos > 0 && topicosInativos > 0) && (topicosAtivos == topicosInativos) ) {
                //50%
                viewModal.find('.fill-percent-bg').css('width', '50%');
                var resultPorcentagemTopicos = '50';
            }

            if(topicosAtivos > 0 && topicosInativos == 0) {
                //100%
                viewModal.find('.fill-percent-bg').css('width', '100%');
                var resultPorcentagemTopicos = '100';
            }

            if(topicosAtivos > 0 && topicosInativos > 0) {
                if(topicosAtivos !== topicosInativos) {
                    var ta = topicosAtivos;
                    var ti = topicosInativos;
                    var totalTopicos = ta + ti;
                    var vp = (ta * 100) / totalTopicos;
                    var resultPorcentagemTopicos = Math.ceil(vp);
                }
            }

            viewModal.find('.fill-percent-bg').css('width', resultPorcentagemTopicos + '%');
            viewModal.find('.lb-percent').text(resultPorcentagemTopicos + '%');

            cardRoteiro.find('.fill-percent-bg').css('width', resultPorcentagemTopicos + '%');
            cardRoteiro.find('.lb-percent').text(resultPorcentagemTopicos + '%');

            editModal.find('#topico_edit_'+id).val(tempCheckboxValue);
        }
    });
}

window.excluirRoteiro = function(id) {
    if ($("#formExcluirRoteiro" + id).length == 0)
        return;

    swal({
        title: 'Excluir roteiro?',
        text: "Você deseja mesmo excluir este roteiro? Todo seu conteúdo será apagado!",
        icon: "warning",
        buttons: ['Não', 'Sim, excluir!'],
        dangerMode: true,
    }).then((result) => {
        if (result == true) {
            $("#formExcluirRoteiro" + id).submit();
        }
    });
}
<file_sep>/app/Http/Controllers/PlanoAulas/Alunos/PlanoAulasController.php
<?php

namespace App\Http\Controllers\PlanoAulas\Alunos;

use App\Entities\PlanoAula\PlanoAula;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PlanoAulasController extends Controller
{

    public function index($idPlano)
    {
        $plano = PlanoAula::find($idPlano);
        return view('pages.plano-aulas.alunos.index', compact('plano'));
    }

}
<file_sep>/app/Http/Controllers/Recentes/Api/RecentesApiController.php
<?php

namespace App\Http\Controllers\Recentes\Api;


use App\Entities\Recente\Recente;
use App\User;
use Carbon\Carbon;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class RecentesApiController extends Controller
{
    public function listar()
    {
        try {
            $recentes = Recente::where('user_id', Auth::user()->id)
                ->with(['albums' => function ($query) {
                    $query->select('albums.id', 'albums.titulo', 'albums.capa as url', 'albums.descricao', 'albums.categoria', 'albums.user_id as artist', 'albums.user_id');
                }])
                ->whereHas('albums')
                ->orderBy('id', 'DESC')
                ->limit(5)
                ->get();
            return response()->json($recentes);
        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao listar.", "message:" => $exception->getMessage()]);
        }

    }




    public function store(Request $request)
    {
        try {
            $exists = Recente::where([['user_id', Auth::user()->id], ['album_id', $request->get('album_id')]])->exists();
            if ($exists) {
                Recente::find($exists->id)->update(['created_at' => Carbon::now()]);
                return response()->json(true);
            }

            if (Recente::where('user_id', Auth::user()->id)->get()->count() >= 5) {
                $check = Recente::where('user_id', Auth::user()->id)->latest()->first();
                $check->delete();
                Recente::create(['user_id' => Auth::user()->id, 'album_id' => $request->get('album_id')]);
                return response()->json(true);
            }

            Recente::create(['user_id' => Auth::user()->id, 'album_id' => $request->get('album_id')]);
            return response()->json(true);

        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao gravar.", "message:" => $exception->getMessage()]);
        }

    }
}
<file_sep>/app/Http/Controllers/Album/Admin/AlbumController.php
<?php

namespace App\Http\Controllers\Album\Admin;

use Illuminate\Support\Facades\Input;

use App\Categoria;
use App\Entities\Album\Album;
use App\Entities\Audio\Audio;
use App\Generals\Upload\Upload;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;

class AlbumController extends Controller
{
    private $resize;

    public function __construct(Upload $resize)
    {
        $this->resize = $resize;
    }

    public function index()
    {
        $albuns = Album::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $albuns->when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $is_admin = strtoupper(Auth::user()->permissao) == "Z";

        $albuns->when($is_admin == false, function ($query) {
            return $query->where('user_id', '=', Auth::user()->id);
        });

        $albuns = $albuns
        ->orderBy('id', 'DESC')
        ->get();

        $categorias = Categoria::where('tipo', 5)->select('id', 'titulo')->get();

        (Auth::user()->permissao == 'Z' ? $audios = Audio::orderBy('id', 'DESC')->get() : $audios = Audio::where('user_id', Auth::user()->id)->orderBy('id', 'DESC')->get());

        return view('pages.albums.admin.index', compact('albuns', 'audios', 'categorias'));
    }

    public function create()
    {
        $categorias = Categoria::where('tipo', 5)->select('id', 'titulo')->get();
        (Auth::user()->permissao == 'Z' ? $audios = Audio::orderBy('id', 'DESC')->get() : $audios = Audio::where('user_id', Auth::user()->id)->orderBy('id', 'DESC')->get());
        return view('pages.albums.admin.create', compact('categorias', 'audios'));
    }

    public function store(Request $request)
    {
        $this->validate($request, ['titulo' => 'required', 'categoria']);

        $album = Album::create([
            'user_id'   => Auth::user()->id,
            'titulo'    => $request->get('titulo'),
            'categoria' => $request->get('categoria'),
            'descricao' => $request->get('descricao')
        ]);

        if ($request->get('audio_id')) {
            $album->audios()->attach($request->get('audio_id'));
        }

        if ($request->capa != null) {
            $fileExtension = \File::extension($request->capa->getClientOriginalName());
            $newFileNameCapa = md5($request->capa->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

            $pathCapa = $request->capa->storeAs('albuns/capas', $newFileNameCapa, 'public_uploads');


            $this->resize->makeSimpleResize($request->capa, 100, 'albuns/capas/app', $newFileNameCapa);


            if (
                !Storage::disk('public_uploads')->put($pathCapa, file_get_contents($request->capa)) ||
                !$this->resize->makeSimpleResize($request->capa, 100, 'albuns/capas/app', $newFileNameCapa)) {
                \Session::flash('middle_popup', 'Ops! Não foi possivel enviar a capa.');
                \Session::flash('popup_style', 'danger');
            } else {
                $album->capa = $newFileNameCapa;
                $album->save();
            }
        }
        return redirect()->back()->with('message', 'Álbum cadastrado com sucesso!');
    }




    public function edit($idAlbum)
    {
        $categorias = Categoria::where('tipo', 5)->select('id', 'titulo')->get();
        (Auth::user()->permissao == 'Z' ? $audios = Audio::orderBy('id', 'DESC')->get() : $audios = Audio::where('user_id', Auth::user()->id)->orderBy('id', 'DESC')->get());
        $album = Album::find($idAlbum);
        return view('pages.albums.admin.edit', compact('categorias', 'audios', 'album'));
    }




    public function update(Request $request, $idAlbum)
    {
        $this->validate($request, ['titulo' => 'required', 'categoria']);
        $capa = $request->get('capa_atual');
        if ($request->file('capa')) {

            if (Storage::disk('public_uploads')->has('albuns/capas/' . $capa)) {
                Storage::disk('public_uploads')->delete('albuns/capas/' . $capa);
                Storage::disk('public_uploads')->delete('albuns/capas/app/' . $capa);
            }

            $fileExtension = \File::extension($request->capa->getClientOriginalName());
            $newFileNameCapa = md5($request->capa->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

            $pathCapa = $request->capa->storeAs('albuns/capas', $newFileNameCapa, 'public_uploads');

            if (!Storage::disk('public_uploads')->put($pathCapa, file_get_contents($request->capa)) ||
                !$this->resize->makeSimpleResize($request->capa, 100, 'albuns/capas/app', $newFileNameCapa)) {
                \Session::flash('middle_popup', 'Ops! Não foi possivel enviar a capa.');
                \Session::flash('popup_style', 'danger');
            } else {
                $capa = $newFileNameCapa;
                Storage::disk('public_uploads')->delete('albuns/capas/' . $request->get('capa_atual'));
                Storage::disk('public_uploads')->delete('albuns/capas/app/' . $request->get('capa_atual'));
            }
        }


        $album = Album::find($idAlbum);
        $album->update([
            'titulo'    => $request->get('titulo'),
            'capa'      => $capa,
            'descricao' => $request->get('descricao'),
            'categoria' => $request->get('categoria')
        ]);

        if (!$request->get('audio_id')) {
            $album->audios()->detach();
        }
        $album->audios()->sync($request->get('audio_id'));

        return redirect()->route('gestao.albuns.listar')->with('message', 'Álbum atualizado com sucesso!');
    }




    public function destroy($idAlbum)
    {
        $album = Album::find($idAlbum);

        if (!$album) {
            return redirect()->back()->withErrors(['Álbum não encontrado!']);
        }

        if (Storage::disk('public_uploads')->has('albuns/capas/' . $album->capa)) {
            Storage::disk('public_uploads')->delete('albuns/capas/' . $album->capa);
            Storage::disk('public_uploads')->delete('albuns/capas/app/' . $album->capa);
        }

        if ($album->audios->toArray()) {
            $album->audios()->detach();
        }
        $album->delete();

        return redirect()->route('gestao.albuns.listar')->with('message', 'Álbum excluida com sucesso!');

    }
}
<file_sep>/app/Http/Controllers/Habilidades/Alunos/HabilidadesController.php
<?php

namespace App\Http\Controllers\Habilidades\Alunos;

use App\Entities\Habilidade\Habilidade;
use App\Entities\HabilidadeUsuario\HabilidadeUsuario;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class HabilidadesController extends Controller
{

    public function index()
    {
        $categorias = Habilidade::select('categoria')->distinct('categoria')->get();//->unique();

        // dd($categorias);

        $habilidades = Habilidade::orderBy('id', 'asc')->get();

        $habilidadesUsuario = HabilidadeUsuario::
        with('habilidade')
        ->where('user_id', Auth::user()->id)
        ->get();

        // dd($habilidades);

        foreach ($categorias as $key => $categoria)
        {
            $categoria->total_pontos = HabilidadeUsuario::with('habilidade')->where([['user_id', Auth::user()->id]])
            ->whereHas('habilidade', function ($query) use ($categoria) {
                $query->where([['categoria', '=', $categoria->categoria]]);
            })
            ->sum('pontos');

            $categoria->total_habilidades = Habilidade::where([['categoria', '=', $categoria->categoria]])->count();
        }

        foreach ($habilidades as $key => $habilidade)
        {
            $habilidade->pontos = HabilidadeUsuario::where([['user_id', Auth::user()->id], ['habilidade_id', '=', $habilidade->id]])
            ->sum('pontos');
        }

        return view('pages.habilidades.alunos.index', compact('categorias', 'habilidades'));
    }

    public function estatisticas()
    {
        return view('pages.habilidades.alunos.estatisticas');
    }

}
<file_sep>/app/Http/Controllers/LiberacaoController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\User;
use App\Aplicacao;
use App\LiberacaoAplicacaoUser;
use App\LiberacaoAplicacaoEscola;
use App\AlunoTurma;
use App\Turma;

class LiberacaoController extends Controller
{

    public function postLiberarAplicacaoEscola(Request $request)
    {
        if($request->tipo_liberacao == 2)
        {
            $request->validate([
                'escola_id' => 'required|exists:escolas,id',
            ]);

            foreach (Aplicacao::where('colecao_id', '=', $request->colecao_id)->get() as $key => $aplicacao)
            {
                if(LiberacaoAplicacaoEscola::where([['escola_id', '=', $request->escola_id], ['aplicacao_id', '=', $aplicacao->id]])->exists() == false)
                {
                    LiberacaoAplicacaoEscola::create([
                        'aplicacao_id' => $aplicacao->id,
                        'escola_id' => $request->escola_id,
                    ]);
                }
            }

            Session::flash("message", 'Coleção liberada com sucesso!');
        }
        else
        {
            $request->validate([
                'aplicacao_id' => 'required|exists:aplicacoes,id',
                'escola_id' => 'required|exists:escolas,id',
            ]);

            if(LiberacaoAplicacaoEscola::where([['escola_id', '=', $request->escola_id], ['aplicacao_id', '=', $request->aplicacao_id]])->exists() == false)
            {
                LiberacaoAplicacaoEscola::create([
                    'aplicacao_id' => $request->aplicacao_id,
                    'escola_id' => $request->escola_id,
                ]);
            }

            Session::flash("message", 'Aplicação liberada com sucesso!');
        }

        return redirect()->back();
    }

    // public function postExcluirLiberarAplicacaoEscola($idAplicacao, $idEscola)
    // {
    //     if(LiberacaoAplicacaoEscola::where([['aplicacao_id', $idAplicacao], ['escola_id', $idEscola]])->exists())
    //     {
    //         LiberacaoAplicacaoEscola::where([['aplicacao_id', $idAplicacao], ['escola_id', $idEscola]])->delete();

    //         return response()->json(["success" => "Liberação excluída com sucesso!"]);
    //     }
    //     else
    //     {
    //         return response()->json(["error" => "Liberação não encontrada!"]);
    //     }
    // }

    public function postExcluirLiberarAplicacaoEscola($idLiberacao)
    {
        if(LiberacaoAplicacaoEscola::find($idLiberacao) != null)
        {
            LiberacaoAplicacaoEscola::find($idLiberacao)->delete();

            return response()->json(["success" => "Liberação excluída com sucesso!"]);
        }
        else
        {
            return response()->json(["error" => "Liberação não encontrada!"]);
        }
    }

    public function postLiberacaoAplicacaoUser($idTurma, Request $request)
    {
        if(Turma::find($idTurma) != null)
        {
            if(Aplicacao::find($request->idAplicacao) != null)
            {
                $alunos = json_decode($request->alunos);

                if($alunos == null)
                {
                    // return redirect()->back()->withErrors("Você deve selecionar ao menos um aluno!");
                    $alunos = [];
                }
                // if(count($alunos) == 0)
                // {
                //     return redirect()->back()->withErrors("Você deve selecionar ao menos um aluno!");
                // }

                if($request->quais == "nenhum")
                {
                    LiberacaoAplicacaoUser::where([['aplicacao_id', '=', $request->idAplicacao]])->whereNotIn('user_id', $alunos)->delete();

                    foreach($alunos as $aluno)
                    {
                        if(!LiberacaoAplicacaoUser::where([['aplicacao_id', '=', $request->idAplicacao], ['user_id', '=', $aluno]])->exists())
                        {
                            LiberacaoAplicacaoUser::create([
                                'aplicacao_id' => $request->idAplicacao,
                                'user_id' => $aluno
                            ]);
                        }
                    }
                }
                else
                {
                    LiberacaoAplicacaoUser::where([['aplicacao_id', '=', $request->idAplicacao]])->whereIn('user_id', $alunos)->delete();

                    foreach(AlunoTurma::where([['turma_id', '=', $idTurma]])->whereNotIn('user_id', $alunos)->get() as $aluno)
                    {
                        if(!LiberacaoAplicacaoUser::where([['aplicacao_id', '=', $request->idAplicacao], ['user_id', '=', $aluno->user_id]])->exists())
                        {
                            LiberacaoAplicacaoUser::create([
                                'aplicacao_id' => $request->idAplicacao,
                                'user_id' => $aluno->user_id
                            ]);
                        }
                    }
                }

                Session::flash("message", 'Aplicação liberada com sucesso para ' . count($alunos) . ' aluno' . (count($alunos) != 1 ? 's' : '' ) . '!');
                return redirect()->back();

            }
            else
            {
                return redirect()->back()->withErrors("Aplicação não encontrada!");
            }
        }
        else
        {
            return redirect()->back()->withErrors("Turma não encontrada!");
        }
    }
}
<file_sep>/app/Http/Controllers/CodigoTransmissaoController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\User;
use App\Conteudo;
use App\Aplicacao;
use App\CodigoTransmissao;
use App\Turma;

class CodigoTransmissaoController extends Controller
{
    public function index(Request $request)
    {
        $transmissao = CodigoTransmissao::where([['id', '=', $request->codigo], ['status', '=', 1]])->orWhere([['token', '=', $request->codigo], ['status', '=', 1]])->first();

        if($transmissao == null)
        {
            return Redirect::back()->withErrors(['Transmissão não encontrada!']);
        }
        else
        {
            // Aplicacao
            if($transmissao->tipo == 1)
            {
                if(Aplicacao::find($transmissao->referencia_id) != null)
                {
                    return redirect()->route('aplicacao', ['idAplicacao' => $transmissao->referencia_id]);
                }
                else
                {
                    return Redirect::back()->withErrors(['Aplicação não encontrada!']);
                }
            }
            // Conteudo
            else if($transmissao->tipo == 2)
            {
                if(Conteudo::find($transmissao->referencia_id) != null)
                {
                    return redirect()->route('conteudo.play', ['idConteudo' => $transmissao->referencia_id]);
                }
                else
                {
                    return Redirect::back()->withErrors(['Conteúdo não encontrado!']);
                }
            }
            else
            {
                return Redirect::back()->withErrors(['Transmissão não encontrada!']);
            }
        }

        return Redirect::back()->withErrors(['Transmissão não encontrada!']);
    }

    public function token($token)
    {
        $transmissao = CodigoTransmissao::where([['id', '=', $token], ['status', '=', 1]])->orWhere([['token', '=', $token], ['status', '=', 1]])->first();

        if($transmissao == null)
        {
            return Redirect::back()->withErrors(['Transmissão não encontrada!']);
        }
        else
        {
            // Aplicacao
            if($transmissao->tipo == 1)
            {
                if(Aplicacao::find($transmissao->referencia_id) != null)
                {
                    return redirect()->route('aplicacao', ['idAplicacao' => $transmissao->referencia_id]);
                }
                else
                {
                    return Redirect::back()->withErrors(['Aplicação não encontrada!']);
                }
            }
            // Conteudo
            else if($transmissao->tipo == 2)
            {
                if(Conteudo::find($transmissao->referencia_id) != null)
                {
                    return redirect()->route('conteudo.play', ['idConteudo' => $transmissao->referencia_id]);
                }
                else
                {
                    return Redirect::back()->withErrors(['Conteúdo não encontrado!']);
                }
            }
            else
            {
                return Redirect::back()->withErrors(['Transmissão não encontrada!']);
            }
        }

        return Redirect::back()->withErrors(['Transmissão não encontrada!']);
    }

    public function postNovoCodigoTransmissao($idTurma, Request $request)
    {
        if(Turma::find($idTurma) != null)
        {
            if($request->tipo == 1)
            {
                if(Aplicacao::find($request->idAplicacao) != null)
                {
                    CodigoTransmissao::create([
                        'user_id' => Auth::user()->id,
                        'token' => $request->codigo,
                        'referencia_id' => $request->idAplicacao,
                        'tipo' => $request->tipo,
                    ]);

                    Session::flash("message", 'Código de transmissão criado com sucesso! Agora é só usar o código: ' . $request->codigo . ' para acessar sua aplicação.');
                    return redirect()->back();
                }
                else
                {
                    return redirect()->back()->withErrors("Aplicação não encontrada!");
                }
            }
            else
            {
                if(Conteudo::find($request->idConteudo) != null)
                {
                    CodigoTransmissao::create([
                        'user_id' => Auth::user()->id,
                        'token' => $request->codigo,
                        'referencia_id' => $request->idConteudo,
                        'tipo' => $request->tipo,
                    ]);

                    Session::flash("message", 'Código de transmissão criado com sucesso! Agora é só usar o código: ' . $request->codigo . ' para acessar seu conteúdo.');
                    return redirect()->back();
                }
                else
                {
                    return redirect()->back()->withErrors("Conteúdo não encontrado!");
                }
            }
        }
        else
        {
            return redirect()->back()->withErrors("Turma não encontrada!");
        }
    }

    public function postExcluirCodigoTransmissao($idTransmissao)
    {
        if(CodigoTransmissao::find($idTransmissao) != null)
        {
            CodigoTransmissao::find($idTransmissao)->delete();

            return response()->json(["success" => "Transmissão encerrada com sucesso!"]);
        }
        else
        {
            return response()->json(["error" => "Transmissão não encontrada!"]);
        }
    }

    public function getTokenRandomico()
    {
        $step = 0;

        do
        {
            if($step < 10)
            {
                $token = \HelperClass::RandomString(4);
            }
            else if($step < 20)
            {
                $token = \HelperClass::RandomString(6);
            }
            else if($step < 30)
            {
                $token = \HelperClass::RandomString(10);
            }
            else if($step < 40)
            {
                $token = \HelperClass::RandomString(12);
            }
            else
            {
                $token = \HelperClass::RandomString(15);
            }

            $step ++;

        } while(CodigoTransmissao::where('token', '=', $token)->exists() && $step < 50);

        if($step >= 50)
        {
            return response()->json(['error' => 'Não foi possível gerar um token aleatório, por favor tente novamente.', 'step' => $step]);
        }
        else
        {
            return response()->json(['success' => 'Token aleatório gerado com sucesso!', 'step' => $step, 'token' => $token]);
        }
    }

}
<file_sep>/app/Http/Controllers/CatalogoController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Escola;
use App\Categoria;
use App\Curso;
use App\Aplicacao;
use App\Conteudo;
use App\AvaliacaoInstrutor;
use App\Matricula;
use App\Metrica;

class CatalogoController extends Controller
{
    public function index()
    {
        if(Input::get('qt') == null)
            $amount = 10;
        else
            $amount = Input::get('qt');

        if(Input::get('ordem') == null)
            $ordem = "recentes";
        else
            $ordem = Input::get('ordem');

        if(Input::get('categoria') == null)
            $categoria = "";
        elseif(Input::get('categoria') == "geral")
            $categoria = "";
        else
            $categoria = Input::get('categoria');

        if($categoria != null)
        {
            if(Categoria::where('titulo', '=', $categoria)->first() != null)
            {
                $categoria = Categoria::where('titulo', '=', $categoria)->first()->id;
            }
        }

        if(Input::get('pesquisa') == null || Input::get('pesquisa') == "")
        {
            $pesquisa = null;

            if($categoria != null)
            {
                $cursos = Curso::take($amount)->where([['status', '=', '1'], ['categoria', '=', $categoria]]);

                $aplicacoes = Aplicacao::take($amount)->where([['status', '=', '1'], ['categoria', '=', $categoria]]);
            }
            else
            {
                $cursos = Curso::take($amount)->where([['status', '=', '1']]);

                $aplicacoes = Aplicacao::take($amount)->where([['status', '=', '1']]);
            }
        }
        else
        {
            $cursos = Curso::take($amount)->where([['status', '=', '1'], ['titulo', 'like', '%' . Input::get('pesquisa') . '%']])
            ->orWhere([['status', '=', '1'], ['descricao', 'like', '%' . Input::get('pesquisa') . '%']]);

            $aplicacoes = Aplicacao::take($amount)->where([['status', '=', '1'], ['titulo', 'like', '%' . Input::get('pesquisa') . '%']])
            ->orWhere([['status', '=', '1'], ['descricao', 'like', '%' . Input::get('pesquisa') . '%']]);
        }

        // $aplicacoes = $aplicacoes->orderBy('data_publicacao', 'desc');

        if($ordem == 'recentes')
        {
            $cursos = $cursos->orderBy('created_at', 'desc');

            $aplicacoes = $aplicacoes->orderBy('created_at', 'desc');

            $ordem = "Mais recentes";
        }
        elseif($ordem == 'antigos')
        {
            $cursos = $cursos->orderBy('created_at', 'asc');

            $aplicacoes = $aplicacoes->orderBy('created_at', 'asc');

            $ordem = "Mais antigos";
        }
        elseif($ordem == 'alfabetica')
        {
            $cursos = $cursos->orderBy('titulo', 'asc');

            $aplicacoes = $aplicacoes->orderBy('titulo', 'asc');

            $ordem = "Ordem Alfabética";
        }

        $cursos = $cursos->get();

        $aplicacoes = $aplicacoes->get();

        $categorias = Categoria::take(8)->get();

        $destaques = $aplicacoes->take(3);

        return view('catalogo')->with( compact('cursos', 'aplicacoes', 'pesquisa', 'amount', 'ordem', 'categorias', 'destaques') );
    }
}
<file_sep>/database/migrations/2019_10_02_095038_create_funcionalidades_table.php
<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

use App\Funcionalidade;

class CreateFuncionalidadesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('funcionalidades', function (Blueprint $table) {
            $table->increments('id');
            $table->string('descricao');
            $table->string('codigo');
            $table->timestamps();
        });

        $funcionalidades = [
            // MENU DE GESTÃO (MANAGER)
            ['descricao' => 'Gestão de aplicações', 'codigo' => 'manager.aplicacoes.consultar'],
            ['descricao' => 'Gestão de aplicações', 'codigo' => 'manager.aplicacoes.gravar'],
            // MENU/SUBMENU
            ['descricao' => 'Cards Creator', 'codigo' => 'manager.cards'],
            ['descricao' => 'Gestão de baralhos', 'codigo' => 'manager.cards.baralhos.consultar'],
            ['descricao' => 'Gestão de baralhos', 'codigo' => 'manager.cards.baralhos.gravar'],
            ['descricao' => 'Gestão de carreiras', 'codigo' => 'manager.cards.carreiras.consultar'],
            ['descricao' => 'Gestão de carreiras', 'codigo' => 'manager.cards.carreiras.gravar'],
            // MENU/SUBMENU (FIM)
            ['descricao' => 'Gestão de cursos', 'codigo' => 'manager.cursos.consultar'],
            ['descricao' => 'Gestão de cursos', 'codigo' => 'manager.cursos.gravar'],
            ['descricao' => 'Gestão de trilhas', 'codigo' => 'manager.trilhas.consultar'],
            ['descricao' => 'Gestão de trilhas', 'codigo' => 'manager.trilhas.gravar'],
            // MENU/SUBMENU
            ['descricao' => 'Cast Creator', 'codigo' => 'manager.cast'],
            ['descricao' => 'Gestão de áudios', 'codigo' => 'manager.cast.audios.consultar'],
            ['descricao' => 'Gestão de áudios', 'codigo' => 'manager.cast.audios.gravar'],
            ['descricao' => 'Gestão de álbuns', 'codigo' => 'manager.cast.albuns.consultar'],
            ['descricao' => 'Gestão de álbuns', 'codigo' => 'manager.cast.albuns.gravar'],
            ['descricao' => 'Gestão de playlists', 'codigo' => 'manager.cast.playlists.consultar'],
            ['descricao' => 'Gestão de playlists', 'codigo' => 'manager.cast.playlists.gravar'],
            ['descricao' => 'Gestão de roteiros', 'codigo' => 'manager.cast.roteiros.consultar'],
            ['descricao' => 'Gestão de roteiros', 'codigo' => 'manager.cast.roteiros.gravar'],
            // MENU/SUBMENU (FIM)
            ['descricao' => 'Gestão de conteúdo', 'codigo' => 'manager.biblioteca.consultar'],
            ['descricao' => 'Gestão de conteúdo', 'codigo' => 'manager.biblioteca.gravar'],
            // MENU/SUBMENU
            ['descricao' => 'Portal do professor', 'codigo' => 'manager.professores'],
            ['descricao' => 'Gestão de artigos', 'codigo' => 'manager.professores.artigos.consultar'],
            ['descricao' => 'Gestão de artigos', 'codigo' => 'manager.professores.artigos.gravar'],
            ['descricao' => 'Cursos para professores', 'codigo' => 'manager.professores.cursos.consultar'],
            ['descricao' => 'Cursos para professores', 'codigo' => 'manager.professores.cursos.gravar'],
            ['descricao' => 'Ranking professor', 'codigo' => 'manager.professores.ranking.consultar'],
            ['descricao' => 'Ranking professor', 'codigo' => 'manager.professores.ranking.gravar'],
            ['descricao' => 'Gestão do Banco de Imagens', 'codigo' => 'manager.professores.imagens.consultar'],
            ['descricao' => 'Gestão do Banco de Imagens', 'codigo' => 'manager.professores.imagens.gravar'],
            // MENU/SUBMENU (FIM)
            ['descricao' => 'Glossário', 'codigo' => 'manager.glossario.consultar'],
            ['descricao' => 'Glossário', 'codigo' => 'manager.glossario.gravar'],
            // MENU/SUBMENU
            ['descricao' => 'Portal de gamificação', 'codigo' => 'manager.gamificacao'],
            ['descricao' => 'Gestão de medalhas', 'codigo' => 'manager.gamificacao.medalhas.consultar'],
            ['descricao' => 'Gestão de medalhas', 'codigo' => 'manager.gamificacao.medalhas.gravar'],
            ['descricao' => 'Gestão de habilidades', 'codigo' => 'manager.gamificacao.habilidades.consultar'],
            ['descricao' => 'Gestão de habilidades', 'codigo' => 'manager.gamificacao.habilidades.gravar'],
            ['descricao' => 'Gestão de configurações', 'codigo' => 'manager.gamificacao.configuracoes.consultar'],
            ['descricao' => 'Gestão de configurações', 'codigo' => 'manager.gamificacao.configuracoes.gravar'],
            // MENU/SUBMENU (FIM)
            ['descricao' => 'Gestão dos testes de nivelamento', 'codigo' => 'manager.nivelamento.consultar'],
            ['descricao' => 'Gestão dos testes de nivelamento', 'codigo' => 'manager.nivelamento.gravar'],
            ['descricao' => 'Gestão do plano de aulas', 'codigo' => 'manager.plano.consultar'],
            ['descricao' => 'Gestão do plano de aulas', 'codigo' => 'manager.plano.gravar'],
            ['descricao' => 'Gestão de turmas', 'codigo' => 'manager.turmas.consultar'],
            ['descricao' => 'Gestão de turmas', 'codigo' => 'manager.turmas.gravar'],
            ['descricao' => 'Mural da escola', 'codigo' => 'manager.mural.escola.consultar'],
            ['descricao' => 'Mural da escola', 'codigo' => 'manager.mural.escola.gravar'],
            ['descricao' => 'Mural da gestão da escola', 'codigo' => 'manager.mural.manager.consultar'],
            ['descricao' => 'Mural da gestão da escola', 'codigo' => 'manager.mural.manager.gravar'],
            ['descricao' => 'Relatórios', 'codigo' => 'manager.relatorios.consultar'],
            ['descricao' => 'Relatórios', 'codigo' => 'manager.relatorios.gravar'],
            ['descricao' => 'Gestão de escolas', 'codigo' => 'manager.escolas.consultar'],
            ['descricao' => 'Gestão de escolas', 'codigo' => 'manager.escolas.gravar'],
            ['descricao' => 'Gestão de usuários', 'codigo' => 'manager.usuarios.consultar'],
            ['descricao' => 'Gestão de usuários', 'codigo' => 'manager.usuarios.gravar'],
            ['descricao' => 'Gestão de categorias', 'codigo' => 'manager.categorias.consultar'],
            ['descricao' => 'Gestão de categorias', 'codigo' => 'manager.categorias.gravar'],
            ['descricao' => 'Gestão financeira', 'codigo' => 'manager.financeiro.consultar'],
            ['descricao' => 'Gestão financeira', 'codigo' => 'manager.financeiro.gravar'],
            ['descricao' => 'Ajuda / FAQ', 'codigo' => 'manager.faq.consultar'],
            ['descricao' => 'Ajuda / FAQ', 'codigo' => 'manager.faq.gravar'],
            ['descricao' => 'Funcionalidades', 'codigo' => 'manager.funcionalidade.consultar'],
            ['descricao' => 'Funcionalidades', 'codigo' => 'manager.funcionalidade.gravar'],
            ['descricao' => 'Plataforma', 'codigo' => 'manager.plataforma.consultar'],
            ['descricao' => 'Plataforma', 'codigo' => 'manager.plataforma.gravar'],
            ['descricao' => 'Documentação API', 'codigo' => 'manager.documentacao.consultar'],
            ['descricao' => 'Documentação API', 'codigo' => 'manager.documentacao.gravar'],
            // FIM MENU GESTÃO

            // MENU DE PROFESSOR (MASTER)
            ['descricao' => 'Gestão de cursos', 'codigo' => 'master.cursos.consultar'],
            ['descricao' => 'Gestão de cursos', 'codigo' => 'master.cursos.gravar'],
            ['descricao' => 'Gestão de trilhas', 'codigo' => 'master.trilhas.consultar'],
            ['descricao' => 'Gestão de trilhas', 'codigo' => 'master.trilhas.gravar'],
            // MENU/SUBMENU
            ['descricao' => 'Cards Creator', 'codigo' => 'master.cards'],
            ['descricao' => 'Gestão de baralhos', 'codigo' => 'master.cards.baralhos.consultar'],
            ['descricao' => 'Gestão de baralhos', 'codigo' => 'master.cards.baralhos.gravar'],
            ['descricao' => 'Gestão de carreiras', 'codigo' => 'master.cards.carreiras.consultar'],
            ['descricao' => 'Gestão de carreiras', 'codigo' => 'master.cards.carreiras.gravar'],
            // MENU/SUBMENU (FIM)
            // MENU/SUBMENU
            ['descricao' => 'Cast Creator', 'codigo' => 'master.cast'],
            ['descricao' => 'Gestão de áudios', 'codigo' => 'master.cast.audios.consultar'],
            ['descricao' => 'Gestão de áudios', 'codigo' => 'master.cast.audios.gravar'],
            ['descricao' => 'Gestão de álbuns', 'codigo' => 'master.cast.albuns.consultar'],
            ['descricao' => 'Gestão de álbuns', 'codigo' => 'master.cast.albuns.gravar'],
            ['descricao' => 'Gestão de playlists', 'codigo' => 'master.cast.playlists.consultar'],
            ['descricao' => 'Gestão de playlists', 'codigo' => 'master.cast.playlists.gravar'],
            ['descricao' => 'Gestão de roteiros', 'codigo' => 'master.cast.roteiros.consultar'],
            ['descricao' => 'Gestão de roteiros', 'codigo' => 'master.cast.roteiros.gravar'],
            // MENU/SUBMENU (FIM)
            ['descricao' => 'Gestão de conteúdo', 'codigo' => 'master.biblioteca.consultar'],
            ['descricao' => 'Gestão de conteúdo', 'codigo' => 'master.biblioteca.gravar'],
            // MENU/SUBMENU
            ['descricao' => 'Portal do professor', 'codigo' => 'master.professores'],
            ['descricao' => 'Gestão de artigos', 'codigo' => 'master.professores.artigos.consultar'],
            ['descricao' => 'Gestão de artigos', 'codigo' => 'master.professores.artigos.gravar'],
            ['descricao' => 'Cursos para professores', 'codigo' => 'master.professores.cursos.consultar'],
            ['descricao' => 'Cursos para professores', 'codigo' => 'master.professores.cursos.gravar'],
            ['descricao' => 'Ranking professor', 'codigo' => 'master.professores.ranking.consultar'],
            ['descricao' => 'Ranking professor', 'codigo' => 'master.professores.ranking.gravar'],
            ['descricao' => 'Gestão do Banco de Imagens', 'codigo' => 'master.professores.imagens.consultar'],
            ['descricao' => 'Gestão do Banco de Imagens', 'codigo' => 'master.professores.imagens.gravar'],
            // MENU/SUBMENU (FIM)
            ['descricao' => 'Glossário', 'codigo' => 'master.glossario.consultar'],
            ['descricao' => 'Glossário', 'codigo' => 'master.glossario.gravar'],
            // MENU/SUBMENU
            ['descricao' => 'Portal de gamificação', 'codigo' => 'master.gamificacao'],
            ['descricao' => 'Gestão de medalhas', 'codigo' => 'master.gamificacao.medalhas.consultar'],
            ['descricao' => 'Gestão de medalhas', 'codigo' => 'master.gamificacao.medalhas.gravar'],
            ['descricao' => 'Gestão de habilidades', 'codigo' => 'master.gamificacao.habilidades.consultar'],
            ['descricao' => 'Gestão de habilidades', 'codigo' => 'master.gamificacao.habilidades.gravar'],
            ['descricao' => 'Gestão de configurações', 'codigo' => 'master.gamificacao.configuracoes.consultar'],
            ['descricao' => 'Gestão de configurações', 'codigo' => 'master.gamificacao.configuracoes.gravar'],
            // MENU/SUBMENU (FIM)
            ['descricao' => 'Gestão dos testes de nivelamento', 'codigo' => 'master.nivelamento.consultar'],
            ['descricao' => 'Gestão dos testes de nivelamento', 'codigo' => 'master.nivelamento.gravar'],
            ['descricao' => 'Gestão do plano de aulas', 'codigo' => 'master.plano.consultar'],
            ['descricao' => 'Gestão do plano de aulas', 'codigo' => 'master.plano.gravar'],
            ['descricao' => 'Gestão de turmas', 'codigo' => 'master.turmas.consultar'],
            ['descricao' => 'Gestão de turmas', 'codigo' => 'master.turmas.gravar'],
            ['descricao' => 'Mural da escola', 'codigo' => 'master.mural.escola.consultar'],
            ['descricao' => 'Mural da escola', 'codigo' => 'master.mural.escola.gravar'],
            ['descricao' => 'Mural da gestão da escola', 'codigo' => 'master.mural.manager.consultar'],
            ['descricao' => 'Mural da gestão da escola', 'codigo' => 'master.mural.manager.gravar'],
            ['descricao' => 'Entregáveis', 'codigo' => 'master.entregaveis.consultar'],
            ['descricao' => 'Entregáveis', 'codigo' => 'master.entregaveis.gravar'],
            ['descricao' => 'Dúvidas de alunos', 'codigo' => 'master.alunos.duvidas.consultar'],
            ['descricao' => 'Dúvidas de alunos', 'codigo' => 'master.alunos.duvidas.gravar'],
            ['descricao' => 'Relatórios', 'codigo' => 'master.relatorios.consultar'],
            ['descricao' => 'Relatórios', 'codigo' => 'master.relatorios.gravar'],
            // FIM MENU PROFESSOR

            // MENU ALUNO
            ['descricao' => 'Home do aluno', 'codigo' => 'play.home.consultar'],
            ['descricao' => 'Home do aluno', 'codigo' => 'play.home.gravar'],
            ['descricao' => 'Central de jogos', 'codigo' => 'play.jogos.consultar'],
            ['descricao' => 'Agenda do aluno', 'codigo' => 'play.agenda.consultar'],
            ['descricao' => 'Agenda do aluno', 'codigo' => 'play.agenda.gravar'],
            ['descricao' => 'Grade de aula', 'codigo' => 'play.grade.consultar'],
            ['descricao' => 'Grade de aula', 'codigo' => 'play.grade.gravar'],
            ['descricao' => 'Trilhas do aluno', 'codigo' => 'play.trilhas.consultar'],
            ['descricao' => 'Trilhas do aluno', 'codigo' => 'play.trilhas.gravar'],
            ['descricao' => 'Teste de nivelamento', 'codigo' => 'play.nivelamento.consultar'],
            ['descricao' => 'Teste de nivelamento', 'codigo' => 'play.nivelamento.gravar'],
            ['descricao' => 'Estatíscias e habilidades', 'codigo' => 'play.estatisca.consultar'],
            ['descricao' => 'Estatíscias e habilidades', 'codigo' => 'play.estatisca.gravar'],
            ['descricao' => 'Conquistas e recompensas', 'codigo' => 'play.conquistas.consultar'],
            ['descricao' => 'Conquistas e recompensas', 'codigo' => 'play.conquistas.gravar'],
            //MENU/SUBMENU
            ['descricao' => 'Sala de estudos', 'codigo' => 'play.estudos'],
            ['descricao' => 'Artigos do aluno', 'codigo' => 'play.estudos.artigos.consultar'],
            ['descricao' => 'Artigos do aluno', 'codigo' => 'play.estudos.artigos.gravar'],
            ['descricao' => 'Biblioteca do aluno', 'codigo' => 'play.estudos.biblioteca.consultar'],
            ['descricao' => 'Biblioteca do aluno', 'codigo' => 'play.estudos.biblioteca.gravar'],
            ['descricao' => 'Glossário do aluno', 'codigo' => 'play.estudos.glossario.consultar'],
            ['descricao' => 'Glossário do aluno', 'codigo' => 'play.estudos.glossario.gravar'],
            //MENU/SUBMENU (FIM)
            //MENU/SUBMENU
            ['descricao' => 'Comunidade', 'codigo' => 'play.comunidade.'],
            ['descricao' => 'Mural da escola (aluno)', 'codigo' => 'play.comunidade.escola.consultar'],
            ['descricao' => 'Mural da escola (aluno)', 'codigo' => 'play.comunidade.escola.gravar'],
            ['descricao' => 'Mural da turma (aluno)', 'codigo' => 'play.comunidade.turma.consultar'],
            ['descricao' => 'Mural da turma (aluno)', 'codigo' => 'play.comunidade.turma.gravar'],
            ['descricao' => 'Fale com o professor', 'codigo' => 'play.comunidade.professor.consultar'],
            ['descricao' => 'Fale com o professor', 'codigo' => 'play.comunidade.professor.gravar'],
            ['descricao' => 'Canal do professor', 'codigo' => 'play.comunidade.canal.professor.consultar'],
            ['descricao' => 'Canal do professor', 'codigo' => 'play.comunidade.canal.professor.gravar'],
            //MENU/SUBMENU (FIM)
            //FIM MENU ALUNO

            // MENU NAV BAR
            ['descricao' => 'Gestão', 'codigo' => 'navbar.manager.consultar'],
            ['descricao' => 'Configurações', 'codigo' => 'navbar.configuracoes.consultar'],
            ['descricao' => 'Ajuda', 'codigo' => 'navbar.ajuda']
            //FIM MENU NAV BAR
        ];

        foreach ($funcionalidades as $funcionalidade) {
            Funcionalidade::create([
                'descricao' => $funcionalidade['descricao'],
                'codigo' => $funcionalidade['codigo']
            ]);
        }
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('funcionalidades');
    }
}
<file_sep>/app/Http/Controllers/NotificacaoController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Illuminate\Support\Facades\Storage;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\User;
use App\Notificacao;

class NotificacaoController extends Controller
{
    public function excluirNotificacao($notificaca_id)
    {
        if($notificaca_id == "todas")
        {
            Notificacao::where([['user_id', '=', Auth::user()->id]])->delete();

            return response()->json(['success' => 'Notificações excluídas com sucesso!']);
        }
        else if(Notificacao::where([['user_id', '=', Auth::user()->id], ['id', '=', $notificaca_id]])->first() != null)
        {
            Notificacao::where([['user_id', '=', Auth::user()->id], ['id', '=', $notificaca_id]])->delete();

            return response()->json(['success' => 'Notificação excluída com sucesso!']);
        }
        else
        {
            return response()->json(['error' => 'Notificação não encontrada!']);
        }

    }
}


<file_sep>/app/Http/Controllers/Metricas/Api/MetricasController.php
<?php

namespace App\Http\Controllers\Metricas\Api;

use App\Entities\Metrica\Api\Repository as Metrica;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class MetricasController extends Controller
{
  
  private $metrica;
  
  public function __construct(Metrica $metrica)
  {
    $this->metrica = $metrica;
  }
  
  public function nova(Request $request)
  {
    if ($request->get('titulo') == null) {
      return response()->json(["error" => "O campo Título é obrigatório"]);
    }
    if ($this->metrica->store([
      'titulo'    => $request->get('titulo'),
      'descricao' => $request->get('descricao'),
      'user_id'   => Auth::user()->id
    ])) {
      return response()->json(["success" => "Métrica cadastrada com sucesso!"]);
    }
    return response()->json(["error" => "Erro cadastar uma nova métrica"]);
  }
  
}
<file_sep>/app/Entities/Metrica/Api/Repository.php
<?php

namespace App\Entities\Metrica\Api;


use App\Metrica;

class Repository
{
  private $metrica;
  
  public function __construct(Metrica $metrica)
  {
    $this->metrica = $metrica;
  }
  
  public function store($values)
  {
    return $this->metrica->create($values);
  }
  
}<file_sep>/app/Http/Controllers/DuvidaController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\User;
use App\Conteudo;
use App\Metrica;
use App\AvaliacaoInstrutor;
use App\DuvidaProfessor;
use App\ComentarioDuvidaProfessor;
use App\Turma;

class DuvidaController extends Controller
{
    public function index($idProfessor)
    {
        $professor = User::with('escola')->find($idProfessor);

        if($professor == null)
        {
            return redirect()->back()->withErrors("Professor não encontrado!");
        }
        else if(strtoupper($professor->permissao) != "P" && strtoupper($professor->permissao) != "G" && strtoupper($professor->permissao) != "Z")
        {
            return redirect()->back()->withErrors("Professor não encontrado!");
        }

        if(AvaliacaoInstrutor::where('instrutor_id', '=', $idProfessor)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $idProfessor)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $duvidas = DuvidaProfessor::where([['professor_id', '=', $idProfessor]])
        ->orderBy('status', 'asc')
        ->orderBy('created_at', 'desc')
        ->get();
        // ->sortBy('status');

        foreach ($duvidas as $duvida)
        {
            $duvida->qt_comentarios = ComentarioDuvidaProfessor::where([['duvida_id', '=', $duvida->id]])->count();
        }

        // dd($duvidas);

        return view('duvidas-professor')->with(compact('duvidas', 'professor', 'avaliacaoInstrutor'));
    }

    public function postNovaDuvida($idProfessor, Request $request)
    {
        if(User::find($idProfessor) == null)
        {
            Redirect::back()->withErrors(['Professor não encontrado!']);
        }
        else
        {
            $duvida = DuvidaProfessor::create([
                'professor_id' => $idProfessor,
                'user_id' => Auth::user()->id,
                'titulo' => $request->titulo,
                'descricao' => $request->descricao
            ]);

            return Redirect::back()->with('message', 'Dúvida enviada com sucesso!');
        }
    }

    public function duvida($idProfessor, $idDuvida)
    {
        $duvida = DuvidaProfessor::with('professor', 'user', 'comentarios')->has('professor')->has('user')->find($idDuvida);

        // dd($duvida);

        if($duvida == null)
        {
            return redirect()->route('professor.duvidas', $idProfessor)->withErrors("Dúvida não encontrada!");
        }

        if(AvaliacaoInstrutor::where('instrutor_id', '=', $duvida->professor->id)->avg('avaliacao') > 0)
            $avaliacaoInstrutor = AvaliacaoInstrutor::where('instrutor_id', '=', $duvida->professor->id)->avg('avaliacao');
        else
            $avaliacaoInstrutor = '-';

        $turma = Turma::where([['user_id', '=', Auth::user()->id]])->first();

        return view('duvida-professor')->with(compact('turma', 'duvida', 'avaliacaoInstrutor'));
    }

    public function postAtualizarDuvida($idProfessor, $idDuvida, Request $request)
    {
        // dd($idDuvida);

        if(DuvidaProfessor::find($idDuvida) == null)
        {
            return Redirect::back()->withErrors(['Dúvida não encontrada!']);
        }
        else
        {
            DuvidaProfessor::find($idDuvida)->update([
                'status' => $request->status
            ]);

            return Redirect::back()->with('message', 'Dúvida atualizada com sucesso!');
        }
    }

    public function postExcluirDuvida($idProfessor, $idDuvida)
    {
        if(DuvidaProfessor::find($idDuvida) == null)
        {
            return Redirect::back()->withErrors(['Dúvida não encontrada!']);
        }
        else
        {
            DuvidaProfessor::find($idDuvida)->delete();

            return Redirect::back()->with('message', 'Dúvida excluída com sucesso!');
        }
    }

    public function postEnviarComentarioDuvida($idProfessor, $idDuvida, Request $request)
    {
        if(DuvidaProfessor::find($idDuvida) == null)
        {
            Redirect::back()->withErrors(['Dúvida não encontrada!']);
        }
        else
        {
            $comentario = ComentarioDuvidaProfessor::create([
                'duvida_id' => $idDuvida,
                'user_id' => Auth::user()->id,
                'conteudo' => $request->conteudo
            ]);

            return Redirect::back();//->with('message', 'Comentário enviado com sucesso!');
        }
    }

    public function postExcluirComentarioDuvida($idProfessor, $idDuvida, $idComentario)
    {
        if(ComentarioDuvidaProfessor::find($idComentario) == null)
        {
            return Redirect::back()->withErrors(['Comentário não encontrado!']);
        }
        else
        {
            ComentarioDuvidaProfessor::find($idComentario)->delete();

            return Redirect::back()->with('message', 'Comentário excluído com sucesso!');
        }
    }
}
<file_sep>/resources/js/pages/gestao/audios.js
window.enviarAudio = function () {
    $("#formNovoAudio #divLoading").addClass("d-none");
    $("#formNovoAudio #divEditar").addClass("d-none");

    $("#formNovoAudio #divEnviando").removeClass("d-none");
}

window.atualizarAudio = function () {
    $("#formEditarAudio #divLoading").addClass("d-none");
    $("#formEditarAudio #divEditar").addClass("d-none");

    $("#formEditarAudio #divEnviando").removeClass("d-none");
}
<file_sep>/app/Categoria.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class Categoria extends Model
{
    //Preenchiveis
    protected $fillable = [
        'id',
        'user_id',
        'titulo',
        'tipo',
    ];

    // Tipos de categorias
    // 0 = Geral
    // 1 = Cursos
    // 2 = Conteudos
    // 3 = Aplicacoes
    // 4 = Artigos
    // 5 = Audios

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [

    ];

    // Mutators
    public function getTipoNameAttribute()
    {
        switch ($this->tipo) {
            case 0:
                return "Geral";
                break;
            case 1:
                return "Cursos";
                break;
            case 2:
                return "Conteudos";
                break;
            case 3:
                return "Aplicacoes";
                break;
            case 4:
                return "Artigos";
                break;
            case 5:
                return "Áudios";
                break;

            default:
                return "Geral";
                break;
        }
    }

    //
    // Relationship
    //

    public function conteudo()
    {
        return $this->belongsToMany('App\Conteudo', 'categoria_id');
    }

    public function aplicacao()
    {
        return $this->belongsToMany('App\Aplicacao', 'categoria_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/Entities/Desafio/Desafio.php
<?php

namespace App\Entities\Desafio;

use App\User;
use Illuminate\Database\Eloquent\Model;

class Desafio extends Model
{
    protected $table = "desafios";
    protected $hidden = ['pivot'];

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'titulo',
        'descricao',
    ];

    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }

    public function getIdAttribute($value)
    {
        return "$value";
    }

}
<file_sep>/app/Http/Controllers/PlanoEstudos/Alunos/PlanoEstudosController.php
<?php

namespace App\Http\Controllers\PlanoEstudos\Alunos;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PlanoEstudosController extends Controller
{
    public function index()
    {
        return view('pages.plano-estudos.alunos.index');
    }
}
<file_sep>/database/migrations/2019_08_08_111945_create_curso_completo_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateCursoCompletoTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('curso_completo', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('curso_id');
			$table->integer('user_id');
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('curso_completo');
	}

}
<file_sep>/app/ComentarioDuvidaProfessor.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class ComentarioDuvidaProfessor extends Model
{
    protected $table = 'comentario_duvida_professor';

    //Preenchiveis
    protected $fillable = [
        'duvida_id',
        'user_id',
        'conteudo',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
    ];

    public function duvida()
    {
        return $this->belongsTo('App\DuvidaProfessor', 'duvida_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/Http/Controllers/PlanoAulas/Admin/PlanoAulasController.php
<?php

namespace App\Http\Controllers\PlanoAulas\Admin;

use App\Conteudo;
use App\Entities\GradeAula\GradeAula;
use App\Entities\PlanoAula\PlanoAula;
use App\Entities\PlanoAula\PlanoAulaAnexo;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Session;

class PlanoAulasController extends Controller
{

    private function gradeAulas()
    {
        return GradeAula::where('user_id', Auth::user()->id)->select('titulo', 'id', 'recorrente', 'dia', 'data')->get();
    }

    private function conteudos()
    {
        return Conteudo::select('id', 'titulo')->get();
    }

    private function checkAndStoreAnexos($request, $planoAulaId, $update = null)
    {
        $checkAtividades = array_key_exists('atividades', $request->all());
        $checkMateriais = array_key_exists('materiais', $request->all());

        if ($update === true) {

            if ($checkAtividades) {
                PlanoAulaAnexo::where('plano_aula_id', $planoAulaId)->where('tipo', 1)->delete();
                foreach ($request->get('atividades') as $atividade) {
                    PlanoAulaAnexo::create([
                        'tipo'          => 1,
                        'plano_aula_id' => $planoAulaId,
                        'conteudo_id'   => $atividade
                    ]);
                }
            } else {
                PlanoAulaAnexo::where('plano_aula_id', $planoAulaId)->where('tipo', 1)->delete();
            }

            if ($checkMateriais) {
                PlanoAulaAnexo::where('plano_aula_id', $planoAulaId)->where('tipo', 2)->delete();
                foreach ($request->get('materiais') as $material) {
                    PlanoAulaAnexo::create([
                        'tipo'          => 2,
                        'plano_aula_id' => $planoAulaId,
                        'conteudo_id'   => $material
                    ]);
                }
            } else {
                PlanoAulaAnexo::where('plano_aula_id', $planoAulaId)->where('tipo', 2)->delete();
            }

        }

        if ($checkAtividades) {
            foreach ($request->get('atividades') as $atividade) {
                PlanoAulaAnexo::create([
                    'tipo'          => 1,
                    'plano_aula_id' => $planoAulaId,
                    'conteudo_id'   => $atividade
                ]);
            }
        }

        if ($checkMateriais) {
            foreach ($request->get('materiais') as $material) {
                PlanoAulaAnexo::create([
                    'tipo'          => 2,
                    'plano_aula_id' => $planoAulaId,
                    'conteudo_id'   => $material
                ]);
            }
        }
    }

    private function checkAnoSession($value)
    {
        // Verifica se já existe uma session
        if (Session::has('anos')) {

            // verifica se o valor enviado já existe na session
            if (in_array($value, Session::get('anos'))) {
                $session = Session::get('anos');
                Session::forget('anos');
                Session::put('anos', array_diff($session, [$value]));
            } else {
                // adiciona novo item na sessão
                Session::push('anos', $value);
            }
        } else {
            //Se não existir, cria nova sessão
            Session::put('anos', [$value]);
        }

        // retorna os itens da sessão
        return Session::get('anos');
    }

    private function checkDisciplinaSession($value)
    {
        // Verifica se já existe uma session
        if (Session::has('disciplina')) {

            // verifica se o valor enviado já existe na session
            if (in_array($value, Session::get('disciplina'))) {
                $session = Session::get('disciplina');
                Session::forget('disciplina');
                Session::put('disciplina', array_diff($session, [$value]));
            } else {
                // adiciona novo item na sessão
                Session::push('disciplina', $value);
            }
        } else {
            //Se não existir, cria nova sessão
            Session::put('disciplina', [$value]);
        }

        // retorna os itens da sessão
        return Session::get('disciplina');
    }


    public function getDaysAjax($idGrade)
    {
        $dates = [];
        $checkDates = PlanoAula::where('grade_aula_id', $idGrade)->select('data')->get();
        foreach ($checkDates as $check) {
            $dates[] = date('d/m/Y', strtotime($check->data));
        }
        return $dates;
    }


    public function index()
    {
        Session::forget(['anos', 'disciplina']);
        $gradeAulas = $this->gradeAulas();
        $planos = PlanoAula::where('user_id', Auth::user()->id)->latest('created_at')->paginate(5);
        $anos = PlanoAula::select('ano_serie')->groupBy('ano_serie')->get();
        $disciplinas = PlanoAula::select('materia')->groupBy('materia')->get();
        $conteudos = $this->conteudos();
        return view('pages.plano-aulas.admin.index', compact('gradeAulas', 'planos', 'conteudos', 'anos', 'disciplinas'));
    }


    public function filtrar(Request $request)
    {
        if ($request->get('input-ano')) {
            $filterAno = $this->checkAnoSession($request->get('input-ano'));
            $planos = PlanoAula::where('user_id', Auth::user()->id)
                ->whereIn('ano_serie', $filterAno)
                ->latest('created_at')->paginate(5);
            if (empty($filterAno)) {
                return redirect()->route('gestao.plano-aulas.listar');
            }
        }
        if ($request->get('input-disciplina')) {
            $filterDisciplina = $this->checkDisciplinaSession($request->get('input-disciplina'));
            $planos = PlanoAula::where('user_id', Auth::user()->id)
                ->whereIn('materia', $filterDisciplina)
                ->latest('created_at')->paginate(5);
            if (empty($filterDisciplina)) {
                return redirect()->route('gestao.plano-aulas.listar');
            }
        }

        if (Session::has('anos') && Session::has('disciplina')) {
            $planos = PlanoAula::where('user_id', Auth::user()->id)
                ->whereIn('ano_serie', Session::get('anos'), 'and')
                ->whereIn('materia', Session::get('disciplina'))
                ->latest('created_at')->paginate(5);
        }

        $gradeAulas = $this->gradeAulas();
        $anos = PlanoAula::select('ano_serie')->groupBy('ano_serie')->get();
        $disciplinas = PlanoAula::select('materia')->groupBy('materia')->get();
        $conteudos = $this->conteudos();
        return view('pages.plano-aulas.admin.index', compact('gradeAulas', 'planos', 'conteudos', 'anos', 'disciplinas'));
    }

    public function busca(Request $request)
    {
        Session::forget(['anos', 'disciplina']);
        $gradeAulas = $this->gradeAulas();
        $anos = PlanoAula::select('ano_serie')->groupBy('ano_serie')->get();
        $disciplinas = PlanoAula::select('materia')->groupBy('materia')->get();
        $conteudos = $this->conteudos();
        $planos = PlanoAula::where('user_id', Auth::user()->id)
            ->where('assunto', 'LIKE', '%' . $request->get('search') . '%')
            ->latest('created_at')->paginate(5);
        return view('pages.plano-aulas.admin.index', compact('gradeAulas', 'planos', 'conteudos', 'anos', 'disciplinas'));
    }

    public function store(Request $request)
    {
        $this->validate($request, [
            'grade_aula_id' => 'required',
            'assunto'       => 'required',
            'tarefa_classe' => 'required'
        ]);
        $values = $request->all();
        $values['user_id'] = Auth::user()->id;

        if ($request->get('data')) {
            $values['data'] = date('Y-m-d', strtotime($request->get('data')));
        } else {
            $values['data'] = GradeAula::find($request->get('grade_aula_id'))->data;
        }

        $planoAulaId = PlanoAula::create($values)->id;
        $this->checkAndStoreAnexos($request, $planoAulaId);
        return redirect()->route('gestao.plano-aulas.listar')->with('message', 'Plano de aula cadastrado com sucesso!');
    }

    public function update($idPlano, Request $request)
    {
        $this->validate($request, [
            'grade_aula_id' => 'required',
            'assunto'       => 'required',
            'tarefa_classe' => 'required'
        ]);
        $values = $request->all();
        if ($request->get('data')) {
            $values['data'] = date('Y-m-d', strtotime($request->get('data')));
        } else {
            $values['data'] = GradeAula::find($request->get('grade_aula_id'))->data;
        }
        PlanoAula::find($idPlano)->update($values);
        $this->checkAndStoreAnexos($request, $idPlano, true);
        return redirect()->route('gestao.plano-aulas.listar')->with('message', 'Plano de aula atualizado com sucesso!');
    }


    public function delete(Request $request)
    {
        PlanoAula::find($request->idPlano)->delete();
        return redirect()->route('gestao.plano-aulas.listar')->with('message', 'Plano de aula excluído com sucesso!');
    }


}
<file_sep>/app/Http/Controllers/EntregaveisController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Escola;
use App\Curso;
use App\Aula;
use App\Conteudo;
use App\ConteudoCompleto;
use App\Categoria;

class EntregaveisController extends Controller
{
    public function index()
    {
        // if(strtoupper(Auth::user()->permissao) == "Z")
        {
            $conteudosEntregaveis = Conteudo::with('conteudo_aula')->whereHas('conteudo_aula')->where([['tipo', '=', '7']])->orWhere([['tipo', '=', '10']])->get();
        }
        // else
        // {
        //     $conteudosEntregaveis = Conteudo::where([['tipo', '=', '7'], ['user_id', '=', Auth::user()->id]])->orWhere([['tipo', '=', '10'], ['user_id', '=', Auth::user()->id]])->get();
        // }

        // dd($conteudosEntregaveis);

        $idCursos = [];

        foreach ($conteudosEntregaveis as $key => $conteudo)
        {
            if($conteudo->conteudo_aula != null)
            if(!in_array($conteudo->conteudo_aula->curso_id, $idCursos))
            {
                array_push($idCursos, $conteudo->conteudo_aula->curso_id);
            }
        }

        $cursos = Curso::whereIn('id', $idCursos)->get();

        // dd($cursos);

        // dd($conteudosEntregaveis);

        return view('gestao.entregaveis')->with(compact('cursos'));
    }

    public function getEntregaveisCurso($idCurso)
    {
        if(Curso::find($idCurso) != null)
        {
            $curso = Curso::find($idCurso);
        }
        else
        {
            return redirect()->back()->withErrors("Curso não encontrado!");
        }

        // if(strtolower(Auth::user()->permissao) == "z")
        {
            $conteudos = Conteudo::
            with('conteudo_aula')
            ->whereHas('conteudo_aula', function ($query) use ($idCurso) {
                $query->where([['curso_id', '=', $idCurso]]);
            })
            ->where(function ($query) {
                $query->where([['tipo', '=', '7']])
                ->orWhere([['tipo', '=', '9']])
                ->orWhere([['tipo', '=', '10']]);
            })->get();
        }
        // else
        // {
        //     $conteudos = Conteudo::where([['tipo', '=', '7'], ['user_id', '=', Auth::user()->id]])
        //     ->orWhere([['tipo', '=', '9'], ['curso_id', '=', $idCurso]])
        //     ->orWhere([['tipo', '=', '10'], ['user_id', '=', Auth::user()->id], ['curso_id', '=', $idCurso]])->get();
        // }

        foreach ($conteudos as $index => $conteudo)
        {
            $conteudo->respostas = ConteudoCompleto::with('user')->where([['curso_id', '=', $conteudo->conteudo_aula->curso_id], ['aula_id', '=', $conteudo->conteudo_aula->aula_id], ['conteudo_id', '=', $conteudo->id]])->get();


            $conteudo->data = $conteudo->created_at->format('d/m/Y \à\s H:i');

            if($conteudo->tipo == 7 || $conteudo->tipo == 9)
            {
                $conteudo->conteudo = json_decode($conteudo->conteudo);
            }

            if($conteudo->tipo == 9)
            {
                $conteudo->provaQuiz = true;

                foreach ($conteudo->conteudo as $pergunta)
                {
                    if($pergunta->tipo == 1)
                    {
                        $conteudo->provaQuiz = false;
                    }
                }

                if($conteudo->provaQuiz)
                {
                    $conteudos->forget($index);
                }
            }

            // foreach ($conteudo->respostas as $resposta)
            // {
            //     $resposta->
            // }
        }

        // dd($conteudos);

        return view('gestao.entregaveis')->with(compact('curso', 'conteudos'));
    }

    public function postCorrigirResposta($idCurso, $idResposta, Request $request)
    {
        if(Curso::find($idCurso) != null)
        {
            $curso = Curso::find($idCurso);
        }
        else
        {
            return response()->json(['error' => 'Curso não encontrado!']);
        }

        if(ConteudoCompleto::with('user')->where([['curso_id', '=', $idCurso], ['id', '=', $idResposta]])->first() == null)
        {
            return response()->json(['error' => 'Resposta não encontrada!']);
        }

        $resp = ConteudoCompleto::with('user')->where([['curso_id', '=', $idCurso], ['id', '=', $idResposta]])->first();

        // if(Conteudo::where([['curso_id', '=', $idCurso], ['aula_id', '=', $resp->aula_id], ['id', '=', $resp->conteudo_id]])->first() == null)
        if(Conteudo::whereHas('conteudo_aula', function ($query) use ($idCurso, $resp) {
            $query->where([['curso_id', '=', $idCurso], ['aula_id', '=', $resp->aula_id], ['conteudo_id', '=', $resp->conteudo_id]]);
        })->first() == null)
        {
            return response()->json(['error' => 'Conteúdo não encontrado!']);
        }

        // $conteudo = Conteudo::where([['curso_id', '=', $idCurso], ['aula_id', '=', $resp->aula_id], ['id', '=', $resp->conteudo_id]])->first();
        $conteudo = Conteudo::whereHas('conteudo_aula', function ($query) use ($idCurso, $resp) {
            $query->where([['curso_id', '=', $idCurso], ['aula_id', '=', $resp->aula_id]]);
        })
        ->where([['id', '=', $resp->conteudo_id]])->first();

        $resp->resposta = json_decode($resp->resposta);
        $conteudo->conteudo = json_decode($conteudo->conteudo);

        if($conteudo->tipo == 9)
        {
            $newResp = $request->correta;

            foreach($request->correta as $index => $resposta)
            {
                if($resposta == null)
                {
                    if($conteudo->conteudo[$index]->correta == $resp->resposta[$index])
                    {
                        $newResp[$index] = 1;
                    }
                    else
                    {
                        $newResp[$index] = 0;
                    }
                }
            }

            ConteudoCompleto::with('user')->where([['curso_id', '=', $idCurso], ['id', '=', $idResposta]])->first()->update([
                'correta' => json_encode($newResp)
            ]);
        }
        else
        {
            if($request->correta == null)
            {
                return response()->json(['error' => 'Correção inválida!']);
            }
            elseif($request->correta !== "true" && $request->correta !== "false")
            {
                return response()->json(['error' => 'Correção inválida!', 'correta' => $request->correta ]);
            }

            ConteudoCompleto::with('user')->where([['curso_id', '=', $idCurso], ['id', '=', $idResposta]])->first()->update([
                'correta' => $request->correta === "true" ? 1 : 0
            ]);
        }

        return response()->json(['success' => 'Resposta corrigida com sucesso!']);
    }

    public function getArquivoEntregavel($idResposta)
    {
        if(ConteudoCompleto::with('user')->where([['id', '=', $idResposta]])->first() == null)
        {
            return response()->view('errors.404');
        }

        $resposta = ConteudoCompleto::with('user')->where([['id', '=', $idResposta]])->first();

        if(\Storage::disk('local')->has('uploads/entregavel/aluno/' . $resposta->user_id . '/' . $resposta->resposta))
        {
            return \Storage::disk('local')->response('uploads/entregavel/aluno/' . $resposta->user_id . '/' . $resposta->resposta);
        }
        else
        {
            return response()->view('errors.404');
        }
    }


}
<file_sep>/app/Http/Controllers/API/UserController.php
<?php

namespace App\Http\Controllers\API;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Lang;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\Hash;
use App\Entities\GamificacaoUsuario\GamificacaoUsuario;
use App\Http\Controllers\Controller;
use App\User;
use Tymon\JWTAuth\Facades\JWTAuth;

class UserController extends Controller
{
    public function __construct()
    {
        $user = new User();
    }
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
      try {
        $users = User::all();

        return response()->json(["data" => $users]);
      } catch (\Exception $exception) {
          return response()->json(["error" => true, "message" => $exception->getMessage()], 500);
      }
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {

      try {
        $validate = Validator::make($request->data, [
          'name'            => ['required', 'string', 'max:255'],
          'email'           => ['required', 'string', 'email', 'max:255', 'unique:users'],
          'data_nascimento' => ['required', 'string'],
          'password'        => ['required', 'string', '<PASSWORD>', '<PASSWORD>']
        ]);

        if ($validate->fails())
          return response()->json(["error" => true, "message" => $validate->errors()], 500);

        $dateInput = str_replace("/", '-', $request->data['data_nascimento']);

        $user = User::create([
          'name'             => $request->data['name'],
          'email'            => $request->data['email'],
          'data_nascimento'  => date('Y-m-d', strtotime($dateInput)),
          'password'         => <PASSWORD>($request->data['password']),
          'ultima_atividade' => date("Y-m-d H:i:s")
        ]);

        $GamificacaoUsuario = new GamificacaoUsuario();
        $gamificacao = GamificacaoUsuario::create([
          'xp'      => 0,
          'user_id' => $user->id
        ]);

        $user["xp"] = $gamificacao->xp;
        $user["level"] = $GamificacaoUsuario->getLevel($gamificacao->xp);

        $message = Lang::get("messages.mensagem_cadastro", ["nome" => "Usuário", "artigo" => "o"]);

        return response()->json(["message" => $message, "data" => $user]);
      } catch (\Exception $exception) {
        return response()->json(["error" => true, "message" => $exception->getMessage()], 500);
      }
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
      try {
        $user = User::findOrFail($id);
        $GamificacaoUsuario = new GamificacaoUsuario();

        $xp = GamificacaoUsuario::select('xp')->where('user_id', $user->id)->first()["xp"];

        $user["xp"] = $xp;
        $user["level"] = $GamificacaoUsuario->getLevel($xp);

        return response()->json(["data" => $user]);
      } catch (\Exception $exception) {
          return response()->json(["error" => true, "message" => $exception->getMessage()], 500);
      }
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
      try {
        $user = User::findOrFail($id);

        DB::beginTransaction();
        $user->update($request->data);
        $message = Lang::get("messages.mensagem_atualizado", ["nome" => "Usuário", "artigo" => "o"]);
        DB::commit();

        return response()->json(["message" => $message]);
      } catch (\Exception $exception) {
        return response()->json(["error" => true, "message" => $exception->getMessage()], 500);
      }
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
      try {
        $gamificacao = GamificacaoUsuario::where('user_id', $id);
        $gamificacao->delete();

        $user = User::findOrFail($id);
        $user->delete();

        $message = Lang::get("messages.mensagem_removido", ["nome" => "Usuário", "artigo" => "o"]);

        return response()->json(["message" => $message, "data" => $user]);
      } catch (\Exception $exception) {
        return response()->json(["error" => true, "message" => $exception->getMessage()], 500);
      }
    }
}
<file_sep>/database/migrations/2019_08_08_111945_create_interacao_conteudo_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateInteracaoConteudoTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('interacao_conteudo', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('conteudo_id');
			$table->integer('user_id');
			$table->integer('tipo');
			$table->timestamp('inicio')->default(DB::raw('CURRENT_TIMESTAMP'));
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('interacao_conteudo');
	}

}
<file_sep>/app/Entities/Trilhas/Trilhas.php
<?php

namespace App\Entities\Trilhas;

use App\Curso;
use App\User;
use Illuminate\Database\Eloquent\Model;

class Trilhas extends Model
{
    protected $table = "trilhas";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'titulo',
        'capa',
        'descricao'
    ];




    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }




    /*public function cursos()
    {
        return $this->hasMany(TrilhasCurso::class, 'trilha_id');
    }*/

    public function cursos()
    {
        return $this->belongsToMany(Curso::class, 'trilhas_cursos', 'trilha_id');
    }


}
<file_sep>/app/Http/Controllers/MetricaController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Illuminate\Support\Facades\Storage;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Escola;
use App\User;
use App\Turma;
use App\AlunoTurma;
use App\Metrica;

class MetricaController extends Controller
{
    public function getMetricas()
    {
        $metricas = Metrica::query();

        // $metricas->when( Auth::user()->permissao == "Z", function ($q) {
        //     return $q->where('likes', '>', request('likes_amount', 0));
        // });

        $metricas->when( Auth::user()->permissao == "G" || Auth::user()->permissao == "P", function ($q) {
            return $q->whereHas('user', function ($q) {
                $q->where('escola_id', Auth::user()->escola_id);
            });
        });

        $metricas = $metricas->pluck('titulo')->unique();


        return response()->json(["success" => "Métricas listadas com sucesso.", "metricas" => $metricas]);
    }

    public function getMetrica($titulo, Request $request)
    {
        $request->metrica = $titulo;

        if($request->metrica == null || $request->metrica == "")
        {
            return response()->json(["error" => "Métrica não especificada."]);
        }

        if(Metrica::where([['titulo', $request->metrica]])->exists() == false)
        {
            return response()->json(["error" => "Métrica não encontrada."]);
        }

        // $request->startDateRange = "2018";
        // $request->endDateRange = "2018-11-30";

        if($request->startDateRange != null && $request->startDateRange != "")
        {
            if($this->validateDate($request->startDateRange, "Y") == false && $this->validateDate($request->startDateRange, "Y-m") == false && $this->validateDate($request->startDateRange, "Y-m-d") == false)
            {
                unset($request->startDateRange);
            }
        }
        if($request->endDateRange != null && $request->endDateRange != "")
        {
            if($this->validateDate($request->endDateRange, "Y") == false && $this->validateDate($request->endDateRange, "Y-m") == false && $this->validateDate($request->endDateRange, "Y-m-d") == false)
            {
                unset($request->endDateRange);
            }
        }

        $metrica = Metrica::query();

        $metrica = $metrica->where('titulo', '=', $request->metrica);

        $metrica->when( isset($request->startDateRange), function ($q) use ($request) {
            return $q->where([['created_at', '>=', $request->startDateRange]]);
        });

        $metrica->when( isset($request->endDateRange), function ($q) use ($request) {
            return $q->where([['created_at', '<=', $request->endDateRange]]);
        });

        $metrica->when( Auth::user()->permissao == "Z" && ($request->has('escola') ? $request->escola != null : false), function ($q) use ($request) {
            return $q->whereHas('user', function ($q2) use ($request) {
                $q2->where('escola_id', '=', $request->escola);
            });
        });

        $metrica->when( $request->has('turma') ? $request->turma != null : false, function ($q) use ($request) {
            return $q->whereHas('aluno_turma', function ($q2) use ($request) {
                $q2->where('turma_id', '=', $request->turma);
            });
        });

        $metrica->when( $request->has('aluno') ? $request->aluno != null : false, function ($q) use ($request) {
            // echo $request->aluno; die();
            return $q->whereHas('user', function ($q2) use ($request) {
                $q2->where('user_id', '=', $request->aluno);
            });
        });

        $metrica = $metrica->whereHas('user', function ($q) {
            $q->where('escola_id', Auth::user()->escola_id);
        })
        ->orderBy('created_at', 'asc')
        ->get(['created_at'])
        ->groupBy( function ($item) {
            return Carbon::parse($item->created_at)->format('d/m/Y');
        });

        foreach ($metrica as $key => $item)
        {
            $metrica[$key] = count($item);
        }

        return response()->json(["success" => "Métrica listada com sucesso.", "metrica" => $metrica]);
    }

    private function validateDate($date, $format = 'Y-m-d')
    {
        $d = \DateTime::createFromFormat($format, $date);
        // The Y ( 4 digits year ) returns TRUE for any integer with any number of digits so changing the comparison from == to === fixes the issue.
        return $d && $d->format($format) === $date;
    }
}


<file_sep>/app/Http/Controllers/Importacao/AulaController.php
<?php
namespace App\Http\Controllers\Importacao;

use App\Aula;
use App\Conteudo;
use App\ConteudoAula;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

use Redirect;

class AulaController extends ImportacaoController
{

    public function aula($idCurso, $idAula, Request $request)
    {       
        if($request->hasFile('fileImportAula'))
        {
            if($request->file('fileImportAula')->getClientOriginalExtension() != 'tz')
            {
                return Redirect::back()->withErrors(['Arquivo de importação inválido!']);
            }

            $userId = Auth::user()->id;
            
            $fileContent = file_get_contents($request->file('fileImportAula')->getPathName());
            $decodeAsArray = json_decode($fileContent, true);

            $myArr = $decodeAsArray;

            /* IMPORTA AULA */
            $arrAula = (isset($myArr['aula'])) ? $myArr['aula'] : false;            

            if(!$arrAula)
            {
                return Redirect::back()->withErrors(['Arquivo de importação não é do tipo aula!']);
            }

            unset($arrAula['conteudos']);

            //Adiciona Aula
            $aula = new Aula();  
            $aula->curso_id = $idCurso;
            $aula->user_id = $userId;
            $aula->forceFill($arrAula);
            $aula->save();         
            $insertedAulaId = $aula->id;
            /* */

            /* IMPORTA CONTEUDOS DA AULA */
            $arrConteudosAula = $myArr['aula']['conteudos'];
            foreach($arrConteudosAula as $conteudoAula)
            {
                //Adiciona Conteúdo
                $conteudo = new Conteudo();  
                $conteudo->user_id = $userId;
                $conteudo->forceFill($conteudoAula);
                $conteudo->save();         
                $insertedConteudoId = $conteudo->id;

                //Adiciona Relacionamento do Conteúdo com o Curso/Aula
                $conteudoAula = new ConteudoAula();
                $conteudoAula->ordem = 999;
                $conteudoAula->conteudo_id = $insertedConteudoId;
                $conteudoAula->curso_id = $idCurso;
                $conteudoAula->aula_id = $insertedAulaId;
                $conteudoAula->user_id = $userId;
                $conteudoAula->obrigatorio = 1;
                $conteudoAula->save();
                $insertedConteudoAulaId = $conteudo->id;
            }
            /* */
             
            return Redirect::back()->with('message', 'Aula importada com sucesso!');
        }
        else
        {
            return Redirect::back()->withErrors(['Arquivo de importação não existe!']);
        }
    }

}<file_sep>/app/Http/Controllers/AplicacaoController.php
<?php

namespace App\Http\Controllers;

use App\Entities\Historico\Historico;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\User;
use App\Aplicacao;
use App\LiberacaoAplicacao;
use App\Conteudo;
use App\Categoria;
use App\AlunoTurma;
use App\Turma;
use App\Metrica;

use App\ProgressoConteudo;

class AplicacaoController extends Controller
{
    public function index($idAplicacao)
    {

        $aplicacao = Aplicacao::find($idAplicacao);

        if ($aplicacao == null) {
            \Session::flash('warning', 'Aplicação não encontrada.');
            return redirect()->route('catalogo');
        }

        if (!\Storage::disk('public_uploads')->has('aplicacoes/' . $aplicacao->id) || ($aplicacao->status == 0 && Auth::user()->permissao != "Z")) {
            \Session::flash('warning', 'Aplicação não encontrada.');

            return redirect()->route('catalogo');
        }

        // Histórico
        if (Historico::where([
                ['user_id', Auth::user()->id],
                ['referencia_id', $idAplicacao],
                ['tipo', 1],
                ['created_at', '>', (Carbon::now()->subMinutes(15))]])
                ->exists() == false) {
            Historico::create([
                'user_id'       => Auth::user()->id,
                'referencia_id' => $idAplicacao,
                'tipo'          => 1
            ]);
        }

        if (Metrica::where([
                ['user_id', Auth::user()->id],
                ['titulo', 'Jogar aplicação - ' . $aplicacao->id],
                ['created_at', '>', (Carbon::now()->subMinutes(15))]])
                ->exists() == false) {
            Metrica::create([
                'user_id' => Auth::check() ? Auth::user()->id : 0,
                'titulo'  => 'Jogar aplicação - ' . $aplicacao->id
            ]);
        }


        if (!ProgressoConteudo::where([['conteudo_id', '=', $idAplicacao], ['tipo', '=', 1], ['user_id', '=', Auth::user()->id]])->exists()) {
            ProgressoConteudo::create([
                'conteudo_id' => $idAplicacao,
                'tipo'        => 1,
                'user_id'     => Auth::user()->id
            ]);
        }

        return view('play.aplicacao')->with(compact('aplicacao'));
    }

    public function ultimaAplicacao()
    {
        if (Metrica::where([['user_id', '=', Auth::user()->id], ['titulo', 'like', 'Jogar aplicação%']])->first() != null) {
            $idUltimaAplicacao = str_replace('Jogar aplicação - ', "", Metrica::where([['user_id', '=', Auth::user()->id], ['titulo', 'like', 'Jogar aplicação - %']])->first()->titulo);

            return redirect()->route('aplicacao', ['idAplicacao' => $idUltimaAplicacao]);
        } else {
            \Session::flash('error', 'Você não acessou nenhum aplicação recentemente.');

            return redirect()->route('catalogo');
        }
    }

    public function gestaoAplicacoes()
    {
        $aplicacoes = Aplicacao::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $aplicacoes = Aplicacao::when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        })
        ->get();

        $categorias = Categoria::all();

        return view('gestao.aplicacoes')->with(compact('aplicacoes', 'categorias'));
    }

    public function postCriarAplicacao(Request $request)
    {
        // dd($request);

        if ($request->descricao == null) {
            $request->descricao = "";
        }

        if ($request->arquivo == null)
        {
            return redirect()->back()->withErrors("Arquivo não encontrado, por favor envie um zip válido!");
        }

        if ($request->data_lancamento != null)
        {
            if(date("Y-m-d H:i", strtotime($request->data_lancamento)) == str_replace("T", " ", $request->data_lancamento))
            {
                if(date("Y-m-d H:i") < date("Y-m-d H:i", strtotime($request->data_lancamento)))
                {
                    $request->data_lancamento = date("Y-m-d H:i:s", strtotime(str_replace("T", " ", $request->data_lancamento)));

                    // dd($request->data_lancamento);
                }
                else
                {
                    return redirect()->back()->withErrors("Data de lançamento inválida, você deve preencher uma data e hora que ainda não passaram!");
                }
            }
            else
            {
                return redirect()->back()->withErrors("Data de lançamento inválida, você deve preencher uma data e hora!");
            }
        }

        if($request->marcadores != null)
        {
            $request->marcadores = explode(";", $request->marcadores);
        }

        $aplicacao = Aplicacao::create([
            'user_id'      => Auth::user()->id,
            'titulo'       => $request->titulo,
            'descricao'    => $request->descricao,
            'status'       => $request->status,
            'liberada'     => $request->liberada,
            'data_lancamento'     => $request->data_lancamento,
            'destaque'     => isset($request->destaque) ? true : false,
            'categoria_id'     => $request->categoria,
            'nivel_ensino'     => $request->nivel_ensino,
            'ano_serie'     => $request->ano_serie,
            'tags' => $request->marcadores,
        ]);

        $logFiles = \Zipper::make($request->arquivo)->listFiles();

        // dd($logFiles);

        \Zipper::make($request->arquivo)->extractTo(public_path('uploads') . '/aplicacoes/' . $aplicacao->id . '/');

        if (!\Storage::disk('public_uploads')->has('aplicacoes/' . $aplicacao->id)) {
            $aplicacao->delete();

            return redirect()->back()->withErrors("Não foi possível extrair o conteúdo do zip, por favor envie sua aplicação novamente!");
        }

        // dd($result);

        if ($request->capa != null) {
            $fileExtension = \File::extension($request->capa->getClientOriginalName());
            $newFileNameCapa = md5($request->capa->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

            $pathCapa = $request->capa->storeAs('aplicacoes/capas', $newFileNameCapa, 'public_uploads');

            if (!\Storage::disk('public_uploads')->put($pathCapa, file_get_contents($request->capa))) {
                \Session::flash('error', 'Ops! Não foi possivel enviar a capa.');
            } else {
                $aplicacao->capa = $newFileNameCapa;

                $aplicacao->save();
            }
        }

        Session::flash("message", 'Aplicação criada com sucesso!');

        return redirect()->back();
        //return redirect()->route('gestao.escola');
    }

    public function getAplicacao($idAplicacao)
    {
        if (Aplicacao::find($idAplicacao) != null) {
            return response()->json(['success' => 'Aplicação encontrada.', 'aplicacao' => Aplicacao::find($idAplicacao)]);
        } else {
            return response()->json(['error' => 'Aplicação não encontrada!']);
        }

        return redirect()->back();
    }

    public function postSalvarAplicacao(Request $request)
    {
        if ($request->descricao == null)
        {
            $request->descricao = "";
        }

        if($request->marcadores != null)
        {
            $request->marcadores = explode(";", $request->marcadores);
        }

        // dd($request);

        if (Aplicacao::find($request->idAplicacao) != null)
        {
            $aplicacao = Aplicacao::find($request->idAplicacao);

            if ($request->data_lancamento != null ? ($aplicacao->data_lancamento != date("Y-m-d H:i", strtotime($request->data_lancamento))) : false)
            {
                if(date("Y-m-d H:i", strtotime($request->data_lancamento)) == str_replace("T", " ", $request->data_lancamento))
                {
                    if(date("Y-m-d H:i") < date("Y-m-d H:i", strtotime($request->data_lancamento)))
                    {
                        $request->data_lancamento = date("Y-m-d H:i:s", strtotime(str_replace("T", " ", $request->data_lancamento)));

                        // dd($request->data_lancamento);
                    }
                    else
                    {
                        return redirect()->back()->withErrors("Data de lançamento inválida, você deve preencher uma data e hora que ainda não passaram!");
                    }
                }
                else
                {
                    return redirect()->back()->withErrors("Data de lançamento inválida, você deve preencher uma data e hora!");
                }
            }

            $aplicacao->update([
                'titulo'       => $request->titulo,
                'descricao'    => $request->descricao,
                'status'       => $request->status,
                'liberada'     => $request->liberada,
                'data_lancamento'     => $aplicacao->data_lancamento != date("Y-m-d H:i", strtotime($request->data_lancamento)) ? $request->data_lancamento : $aplicacao->data_lancamento,
                'destaque'     => isset($request->destaque) ? true : false,
                'categoria_id'     => $request->categoria,
                'nivel_ensino'     => $request->nivel_ensino,
                'ano_serie'     => $request->ano_serie,
                'tags' => $request->marcadores
            ]);

            if ($request->capa != null) {
                $fileExtension = \File::extension($request->capa->getClientOriginalName());
                $newFileNameCapa = md5($request->capa->getClientOriginalName() . date("Y-m-d H:i:s") . time()) . '.' . $fileExtension;

                $pathCapa = $request->capa->storeAs('aplicacoes/capas', $newFileNameCapa, 'public_uploads');

                if (!\Storage::disk('public_uploads')->put($pathCapa, file_get_contents($request->capa))) {
                    \Session::flash('error', 'Ops! Não foi possivel enviar a capa.');
                } else {
                    if (\Storage::disk('public_uploads')->has('aplicacoes/capas/' . $aplicacao->capa)) {
                        \Storage::disk('public_uploads')->delete('aplicacoes/capas/' . $aplicacao->capa);
                    }

                    $aplicacao->capa = $newFileNameCapa;

                    $aplicacao->save();
                }
            }

            if ($request->arquivo != null) {
                $logFiles = \Zipper::make($request->arquivo)->listFiles();

                \Zipper::make($request->arquivo)->extractTo(public_path('uploads') . '/aplicacoes/' . $aplicacao->id . '/');

                if (!\Storage::disk('public_uploads')->has('aplicacoes/' . $aplicacao->id)) {
                    return redirect()->back()->withErrors("Não foi possível extrair o conteúdo do zip, por favor atualize sua aplicação novamente!");
                }
            }

            // return response()->json(['success' => 'Aplicação atualizada com sucesso!']);
            Session::flash("message", 'Aplicação atualizada com sucesso!');
            return redirect()->back();
        } else {
            // return response()->json(['error' => 'Aplicação não encontrada!']);
            Session::flash("error", 'Aplicação não encontrada!');
            return redirect()->back();
        }
    }

    public function postExcluirAplicacao($idAplicacao)
    {
        if (Aplicacao::find($idAplicacao) != null) {

            if (\Storage::disk('public_uploads')->has('aplicacoes/capas/' . Aplicacao::find($idAplicacao)->capa)) {
                \Storage::disk('public_uploads')->delete('aplicacoes/capas/' . Aplicacao::find($idAplicacao)->capa);
            }

            if (\Storage::disk('public_uploads')->has('aplicacoes/' . Aplicacao::find($idAplicacao)->id)) {
                \Storage::disk('public_uploads')->deleteDirectory('aplicacoes/' . Aplicacao::find($idAplicacao)->id);
            }

            Aplicacao::find($idAplicacao)->delete();

            return response()->json(["success" => "Aplicação excluída com sucesso!"]);
        } else {
            return response()->json(["error" => "Aplicação não encontrada!"]);
        }
    }

    public function postLiberacaoAplicacao($idTurma, Request $request)
    {
        if (Turma::find($idTurma) != null) {
            if (Aplicacao::find($request->idAplicacao) != null) {
                $alunos = json_decode($request->alunos);

                if ($alunos == null) {
                    // return redirect()->back()->withErrors("Você deve selecionar ao menos um aluno!");
                    $alunos = [];
                }
                // if(count($alunos) == 0)
                // {
                //     return redirect()->back()->withErrors("Você deve selecionar ao menos um aluno!");
                // }

                if ($request->quais == "nenhum") {
                    LiberacaoAplicacao::where([['aplicacao_id', '=', $request->idAplicacao]])->whereNotIn('user_id', $alunos)->delete();

                    foreach ($alunos as $aluno) {
                        if (!LiberacaoAplicacao::where([['aplicacao_id', '=', $request->idAplicacao], ['user_id', '=', $aluno]])->exists()) {
                            LiberacaoAplicacao::create([
                                'aplicacao_id' => $request->idAplicacao,
                                'user_id'      => $aluno
                            ]);
                        }
                    }
                } else {
                    LiberacaoAplicacao::where([['aplicacao_id', '=', $request->idAplicacao]])->whereIn('user_id', $alunos)->delete();

                    foreach (AlunoTurma::where([['turma_id', '=', $idTurma]])->whereNotIn('user_id', $alunos)->get() as $aluno) {
                        if (!LiberacaoAplicacao::where([['aplicacao_id', '=', $request->idAplicacao], ['user_id', '=', $aluno->user_id]])->exists()) {
                            LiberacaoAplicacao::create([
                                'aplicacao_id' => $request->idAplicacao,
                                'user_id'      => $aluno->user_id
                            ]);
                        }
                    }
                }

                Session::flash("message", 'Aplicação liberada com sucesso para ' . count($alunos) . ' aluno' . (count($alunos) != 1 ? 's' : '') . '!');
                return redirect()->back();

            } else {
                return redirect()->back()->withErrors("Aplicação não encontrada!");
            }
        } else {
            return redirect()->back()->withErrors("Turma não encontrada!");
        }
    }
}
<file_sep>/app/Entities/Album/Album.php
<?php

namespace App\Entities\Album;

use App\Entities\Audio\Audio;
use App\User;
use Illuminate\Database\Eloquent\Model;

class Album extends Model
{
    protected $table = "albums";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'titulo',
        'capa',
        'descricao',
        'categoria'
    ];


    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }

    public function categoria()
    {
        return $this->belongsTo('App\Categoria', 'categoria');
    }


    public function audios()
    {
        return $this->belongsToMany(Audio::class, 'album_audios', 'album_id');
    }

    public function getUrlAttribute()
    {
        $path = env("APP_URL") . '/uploads/albuns/capas/app/' . $this->attributes['url'];
        return $path;
    }

    public function getArtistAttribute()
    {
        $user = User::where('id', $this->attributes['artist'])->select('name')->first();
        return $user->name;
    }

    public function getCreatedAtAttribute($date)
    {
        return ucfirst(\Carbon\Carbon::createFromFormat('Y-m-d H:i:s', $date)->diffForHumans());
    }


}
<file_sep>/app/Entities/MarcadorPagina/MarcadorPagina.php
<?php

namespace App\Entities\MarcadorPagina;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class MarcadorPagina extends Model
{
    protected $table = 'marcador_pagina';

    //Preenchiveis
    protected $fillable = [
        'id',
        'conteudo_id',
        'user_id',
        'pagina',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
    ];

    public function conteudo()
    {
        return $this->belongsTo('App\Conteudo', 'conteudo_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/Http/Controllers/Busca/Api/BuscaApiController.php
<?php

namespace App\Http\Controllers\Busca\Api;

use App\Entities\Album\Album;
use App\Entities\Playlist\Playlist;
use App\User;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class BuscaApiController extends Controller
{


    public function listar(Request $request)
    {

        try {
            if ($request->get('text') != '') {

                $albums = Album::orderBy('id', 'DESC')
                    ->select('albums.id', 'albums.titulo', 'albums.capa as url', 'albums.descricao', 'albums.categoria',
                        'albums.user_id as artist', 'albums.user_id')
                    ->where('titulo', 'LIKE', '%' . $request->get('text') . '%')
                    /*->with(['audios' => function ($query) {
                        $query->select('audios.id', 'audios.titulo as title', 'audios.user_id as artist',
                            'audios.file as url', 'audios.descricao', 'audios.duracao as duration');
                    }])*/
                    ->get();

                $playlists = Playlist::orderBy('id', 'DESC')
                    ->where([['user_id', Auth::user()->id], ['titulo', 'LIKE', '%' . $request->get('text') . '%']])
                    ->select('playlists.id', 'playlists.user_id', 'playlists.user_id as artist', 'playlists.titulo', 'playlists.created_at')
                    /*->with(['audios' => function ($query) {
                        $query->select('audios.id', 'audios.titulo as title', 'audios.user_id as artist',
                            'audios.file as url', 'audios.descricao');
                    }])*/
                    ->get();

                $artists = User::orderBy('name', 'ASC')
                    ->select('users.id', 'users.name')
                    ->where('name', 'LIKE', '%' . $request->get('text') . '%')
                    ->with(['albuns' => function ($query) {
                        $query->select('albums.id', 'albums.titulo', 'albums.capa as url', 'albums.descricao', 'albums.categoria',
                            'albums.user_id as artist', 'albums.user_id');

                    }])
                    ->has('albuns')
                    ->get();

                $artistsAlbuns = [];
                foreach ($artists as $artist) {
                    $artistsAlbuns = $artist->albuns;
                }

                return response()->json([
                    'albums'    => ($albums->count() > 0 ? $albums : false),
                    'playlists' => ($playlists->count() > 0 ? $playlists : false),
                    'artists'   => (empty($artistsAlbuns) ? false : $artistsAlbuns)
                ]);

            }

            return null;

        } catch (\Exception $exception) {
            return response()->json(["error" => "Erro ao buscar.", "message:" => $exception->getMessage()]);
        }
    }

}
<file_sep>/app/Http/Controllers/Badges/Alunos/BadgesController.php
<?php

namespace App\Http\Controllers\Badges\Alunos;

use App\Badge;
use App\BadgeUsuario;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class BadgesController extends Controller
{
    public function recompensas()
    {
        $badges = Badge::where([['visibilidade', '=', '1']])->get();

        foreach (BadgeUsuario::with('badge')->whereHas('badge')->where('user_id', '=', Auth::user()->id)->get() as $minha)
        {

            $tem_badge = $badges->contains(function ($value, $key) use ($minha) {
                if($minha->badge != null)
                {
                    return $value->id == $minha->badge->id;
                }
                else
                {
                    return null;
                }
            });

            if ($tem_badge)
            {
                $badges->first(function ($value, $key) use ($minha) {
                    return $value->id == $minha->badge->id;
                })->desbloqueada = true;
            }
            else
            {
                $minha = $minha->badge;
                $minha->desbloqueada = true;
                $badges->push($minha);
            }
        }

        return view('pages.badges.alunos.recompensas')->with(compact('badges'));
    }


    public function desafios()
    {
        return view('pages.badges.alunos.desafios-concluidos');
    }


    public function conquistas()
    {
        $badges = Badge::where([['visibilidade', '=', '1']])->get();

        foreach (BadgeUsuario::with('badge')->whereHas('badge')->where('user_id', '=', Auth::user()->id)->get() as $minha) {
            if ($badges->contains(function ($value, $key) use ($minha) {
                return $value->id == $minha->badge->id;
            })) {
                $badges->first(function ($value, $key) use ($minha) {
                    return $value->id == $minha->badge->id;
                })->desbloqueada = true;
            } else {
                $minha = $minha->badge;
                $minha->desbloqueada = true;
                $badges->push($minha);
            }
        }

        return view('pages.badges.alunos.conquistas')->with(compact('badges'));
    }

}
<file_sep>/app/ConteudoAula.php
<?php

namespace App;

use App\Entities\Favorito\Favorito;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

use Carbon\Carbon;


class ConteudoAula extends Model
{
    protected $table = 'conteudo_aula';

    //Preenchiveis
    protected $fillable = [
        'id',
        'ordem',
        'curso_id',
        'aula_id',
        'conteudo_id',
        'user_id',
        'obrigatorio',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
    ];

    public function conteudo()
    {
        return $this->belongsTo('App\Conteudo', 'conteudo_id');//->where([['curso_id', '=', $this->curso_id], ['aula_id', '=', $this->aula_id]]);
    }

    public function progressos()
    {
        return $this->hasMany('App\ProgressoConteudo', 'conteudo_id')->where('tipo', '=', 2);
    }

    public function progressos_user()
    {
        return $this->hasMany('App\ProgressoConteudo', 'conteudo_id')->with('user')->where('tipo', '=', 2);
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

    public function favorito($idUser, $idRef)
    {
        return $this->hasOne(Favorito::class, 'referencia_id')
            ->where([['user_id', $idUser], ['referencia_id', $idRef], ['tipo', 2]])->first();
    }

}
<file_sep>/app/Http/Controllers/Glossario/Admin/GlossarioController.php
<?php

namespace App\Http\Controllers\Glossario\Admin;

use Illuminate\Support\Facades\Input;

use App\Entities\Glossario\Repository;
use App\Http\Requests\Glossario\Create;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

use App\Entities\Glossario\Glossario;

class GlossarioController extends Controller
{
    private $repository;

    public function __construct(Repository $repository)
    {
      $this->repository = $repository;
    }


    public function create($word)
    {
        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        if($tem_pesquisa)
        {
            $glossarios = $this->repository->search(Input::get('pesquisa'));

            // $word = strtoupper(substr(Input::get('pesquisa'), 0, 1));
            $word = null;
        }
        else
        {
            $glossarios = $this->repository->all($word);
        }

        return view('pages.glossario.admin.create')->with( compact('glossarios', 'word') );
    }

    public function delete(Request $request)
    {
      if(Glossario::find($request->idGlossario) != null)
      {
        Glossario::find($request->idGlossario)->delete();

        return redirect()->route('gestao.glossario.index')->with('success', 'Registro removido com sucesso!');
      }
      else
      {
        return redirect()->route('gestao.glossario.index')->with('error', 'Registro não encontrado!');
      }
    }

    public function store(Create $request)
    {
      $values = $request->all();
      $values['key'] = strtoupper(substr($request->get('word'), 0, 1));
      $this->repository->store($values);
      return redirect()->route('gestao.glossario', ['word' => $values['key']])->with('success', 'Registro adicionado com sucesso!');
    }

}
<file_sep>/app/Badge.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class Badge extends Model
{
  //Preenchiveis
  protected $fillable = [
    'user_id',
    'titulo',
    'descricao',
    'visibilidade',
    'icone'
  ];
  
  // Protegidos
  protected $hidden = [
  ];
  
  //Padrões
  protected $attributes = [
    'descricao'    => '',
    'visibilidade' => 1,
  ];
  
  public function user()
  {
    return $this->belongsTo('App\User', 'user_id');
  }
  
  public function minhas()
  {
    return $this;
  }
  
}
<file_sep>/app/CodigoTransmissao.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class CodigoTransmissao extends Model
{
    protected $table = 'codigo_transmissao';

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'token',
        'referencia_id',
        'tipo',
        'status',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        // 'tipo' => 1,
        'status' => 1,
    ];

    public function aplicacao()
    {
        return $this->belongsTo('App\Aplicacao', 'referencia_id');
    }

    public function conteudo()
    {
        return $this->belongsTo('App\Conteudo', 'referencia_id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id');
    }

}
<file_sep>/app/Notificacao.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class Notificacao extends Model
{
    protected $table = 'notificacoes';

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'titulo',
        'descricao',
        'tipo',
        'link',
        'lida',
    ];

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'descricao' => '',
        'tipo' => 2,
        'link' => '',
        'lida' => 0,
    ];

    public function user()
    {
        return $this->belongsTo('App\User');
    }

}
<file_sep>/database/migrations/2019_08_08_111945_create_comentarios_conteudo_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateComentariosConteudoTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('comentarios_conteudo', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('user_id');
			$table->integer('curso_id');
			$table->integer('aula_id');
			$table->integer('conteudo_id');
			$table->text('comentario');
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('comentarios_conteudo');
	}

}
<file_sep>/app/Entities/GradeAula/GradeAula.php
<?php

namespace App\Entities\GradeAula;

use App\Entities\PlanoAula\PlanoAula;
use App\User;
use Illuminate\Database\Eloquent\Model;

class GradeAula extends Model
{
    protected $table = "grade_aulas";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'turma_id',
        'titulo',
        'descricao',
        'data',
        'data_inicial',
        'hora_inicial',
        'data_final',
        'hora_final',
        'recorrente',
        'dia',
        'cor',
    ];

    public function professor()
    {
        return $this->belongsTo(User::class, 'user_id');
    }

    public function planos()
    {
        return $this->hasMany(PlanoAula::class, 'grade_aula_id');
    }

}
<file_sep>/database/migrations/selected/2019_08_08_111945_create_endereco_user_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateEnderecoUserTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('endereco_user', function(Blueprint $table)
		{
			$table->integer('user_id')->primary();
			$table->string('cep', 9)->nullable();
			$table->string('uf', 2)->nullable();
			$table->string('cidade', 100)->nullable();
			$table->string('bairro', 100)->nullable();
			$table->string('logradouro')->nullable();
			$table->string('numero')->nullable();
			$table->string('complemento')->nullable();
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('endereco_user');
	}

}
<file_sep>/app/Entities/Historico/Historico.php
<?php

namespace App\Entities\Historico;

use App\Conteudo;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Model;

class Historico extends Model
{
    protected $table = "historicos";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'referencia_id',
        'tipo',
    ];


    public function conteudo()
    {
        return $this->belongsTo(Conteudo::class, 'referencia_id');
    }


}
<file_sep>/app/Http/Controllers/CursoController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
// use Request;
use Illuminate\Support\Facades\Input;

use Illuminate\Support\Facades\Storage;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Escola;
use App\Categoria;
use App\Curso;
use App\Aula;
use App\Conteudo;
use App\ConteudoAula;
use App\AvaliacaoCurso;
use App\AvaliacaoInstrutor;
use App\AvaliacaoEscola;
use App\Matricula;
use App\Metrica;
use App\AvaliacaoConteudo;
use App\ComentarioConteudo;
use App\Notificacao;

use App\ConteudoCompleto;
use App\CursoCompleto;

use App\Transacao;
use App\ProdutoTransacao;

use App\MensagemTransmissao;

use App\BadgeUsuario;

class CursoController extends Controller
{
    public function index($idCurso)
    {
        if(is_numeric($idCurso))
        {
            if(Curso::find($idCurso) != null)
            {
                $curso = Curso::with('aulas', 'user', 'avaliacoes_user', 'topicos')->where([['id', '=', $idCurso]])->first();
                // $curso = Curso::with('aulas', 'user', 'avaliacoes_user')->where([['escola_id', '=', $escola->id], ['id', '=', $idCurso]])->first();
            }
        }
        else
        {
            // Verificação comentada, apenas usada se o titulo for codificado com traços ao inves de espaços
            // if(Curso::where('titulo', '=', str_replace('-', ' ', $idCurso))->first() != null)
            if(Curso::where('titulo', '=', $idCurso)->first() != null)
            {
                $curso = Curso::with('aulas', 'user', 'avaliacoes_user', 'topicos')->where([['escola_id', '=', $escola->id], ['titulo', '=', $idCurso]])->first();
            }
            elseif(is_numeric( substr(strrchr($idCurso, "-"), 1) ))
            {
                if(Curso::find(substr(strrchr($idCurso, "-"), 1)) != null)
                {
                    $temp = Curso::find(substr(strrchr($idCurso, "-"), 1));

                    $tempTitulo = mb_strtolower($temp->titulo . '-' . $temp->id, 'utf-8');

                    if($tempTitulo == $idCurso)
                    {
                        $curso = Curso::find(substr(strrchr($idCurso, "-"), 1));
                    }
                }
            }
        }

        // dd(count(array_filter(Session::get('carrinho'), function($k) use ($curso) { return ($k->tipo == 2 && $k->id == $curso->id); })));

        if(isset($curso) ? ($curso == null) : (true))
        {
            Session::flash('error', "Curso não encontrado!");

            return redirect()->route('catalogo');
        }

        if($curso->status != 1)
        {
            if(Auth::check() ? (strtolower(Auth::user()->permissao) != "z" && $curso->user_id != Auth::user()->id) : true)
            {
                Session::flash('error', "Curso não encontrado!");

                return redirect()->route('catalogo');
            }
            else
            {
                Session::flash('previewMode', true);
            }
        }

        if($curso->senha != "" && $curso->senha != null)
        {
            if(Session::has('senhaCurso'. $curso->id))
            {
                if(Session::get('senhaCurso'. $curso->id) != $curso->senha)
                {
                    Session::forget('senhaCurso'. $curso->id);
                    return Redirect::back()->withErrors(['Senha do curso inválida!']);
                }
            }
            else
            {
                // if($curso->escola_id != 1)
                // {
                //     // return Redirect::route('curso.trancado', ['escola_id' => $curso->escola_id, 'idCurso' => $curso->id]);
                // }
                // else
                {
                    return Redirect::route('curso.trancado', ['idCurso' => $curso->id]);
                }
            }
        }

        $curso->duracao = 0;

        foreach ($curso->aulas as $key => $aula)
        {
            // $aula->conteudos = Conteudo::where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]])->orderBy('ordem', 'asc')->get();
            $aula->conteudos = Conteudo::
            with('conteudo_aula')
            ->whereHas('conteudo_aula', function ($query) use ($curso, $aula) {
                $query->where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]]);
            })
            // ->orderBy('ordem', 'asc')
            ->get()
            ->sortBy('conteudo_aula.ordem');

            $aula->conteudos = Conteudo::detalhado($aula->conteudos);

            $aula->duracao = Conteudo::
            whereHas('conteudo_aula', function ($query) use ($curso, $aula) {
                $query->where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]]);
            })
            ->sum('duracao');

            if($aula->duracao == 0)
            {
                $aula->duracao = count($aula->conteudos) * 120;
            }


            $curso->duracao += $aula->duracao;

            if($aula->duracao > 60)
            {
                $horas = floor($aula->duracao / 60);
                $minutos = number_format((($aula->duracao / 60) - $horas) * 60, 0);
                $aula->duracao = $horas . ':' . ($minutos < 10 ? '0' . $minutos : $minutos);
            }
            else
            {
                $aula->duracao = '00:' . ($aula->duracao < 10 ? '0' . $aula->duracao : $aula->duracao);
            }
        }

        if($curso->duracao > 60)
        {
            $horas = floor($curso->duracao / 60);
            $minutos = number_format((($curso->duracao / 60) - $horas) * 60, 0);
            $curso->duracao = $horas . ':' . ($minutos < 10 ? '0' . $minutos : $minutos);
        }
        else
        {
            $curso->duracao = '00:' . ($curso->duracao < 10 ? '0' . $curso->duracao : $curso->duracao);
        }

        if(AvaliacaoCurso::where('curso_id', '=', $curso->id)->avg('avaliacao') > 0)
            $curso->avaliacao = AvaliacaoCurso::where('curso_id', '=', $curso->id)->avg('avaliacao');
        else
            $curso->avaliacao = 5;

        if(AvaliacaoInstrutor::where('instrutor_id', '=', $curso->user_id)->avg('avaliacao') > 0)
            $curso->user->avaliacao = AvaliacaoInstrutor::where('instrutor_id', '=', $curso->user_id)->avg('avaliacao');
        else
            $curso->user->avaliacao = 5;

        if(AvaliacaoEscola::where('escola_id', '=', $curso->escola_id)->avg('avaliacao') > 0)
            $curso->avaliacao_escola = AvaliacaoEscola::where('escola_id', '=', $curso->escola_id)->avg('avaliacao');
        else
            $curso->avaliacao_escola = 5;

        Metrica::create([
            'user_id' => Auth::check() ? Auth::user()->id : 0,
            'titulo' => 'Visualização curso - ' . $curso->id
        ]);

        $curso->visualizacoes = Metrica::where('titulo', '=', 'Visualização curso - ' . $curso->id)->count();

        $matricula = Auth::check() ? Matricula::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $curso->id]])->first() : null;

        $curso->transacoes = null;

        $curso->statusPagamento = null;

        if(Auth::check())
        {
            $curso->transacoes = collect();

            foreach (ProdutoTransacao::where([['user_id', '=', Auth::user()->id], ['produto_id', '=', $curso->id]])->get() as $produto)
            {
                if(Transacao::where('referencia_id', $produto->transacao_id)->first() != null)
                {
                    $curso->transacoes->push( Transacao::where('referencia_id', $produto->transacao_id)->first() );
                }
            }

            // dd(ProdutoTransacao::where([['user_id', '=', Auth::user()->id], ['produto_id', '=', $curso->id]])->get());

            $curso->transacoes = $curso->transacoes->unique(function ($item) {
                return $item->id;
            });

            if(count($curso->transacoes) > 0)
            {
                $curso->statusPagamento = $curso->transacoes[0]->status;
            }

            foreach ($curso->transacoes as $transacao)
            {
                if($transacao->status == 3 || $transacao->status == 4)
                {
                    $curso->statusPagamento = $transacao->status;
                    break;
                }
            }
        }

        // dd($curso->avaliacoes_user[0]->user->name);
        // dd($curso);

        // dd($curso->transacoes);
        // dd($curso->topicos);

        return view('curso.index')->with(compact('curso', 'matricula'));
    }

    public function cursoTrancado($idCurso)
    {
        if(is_numeric($idCurso))
        {
            if(Curso::find($idCurso) != null)
            {
                $curso = Curso::with('aulas', 'user', 'avaliacoes_user')->find($idCurso);
            }
        }
        else
        {
            if(Curso::where('titulo', '=', str_replace('-', ' ', $idCurso))->first() != null)
            {
                $curso = Curso::with('aulas', 'user', 'avaliacoes_user')->where('titulo', '=', str_replace('-', ' ', $idCurso))->first();
            }
            elseif(is_numeric( substr(strrchr($idCurso, "-"), 1) ))
            {
                if(Curso::find(substr(strrchr($idCurso, "-"), 1)) != null)
                {
                    $temp = Curso::find(substr(strrchr($idCurso, "-"), 1));

                    $tempTitulo = mb_strtolower(str_replace(' ', '-', $temp->titulo) . '-' . $temp->id, 'utf-8');

                    if($tempTitulo == $idCurso)
                    {
                        $curso = Curso::find(substr(strrchr($idCurso, "-"), 1));
                    }
                }
            }
        }

        if(isset($curso) ? ($curso == null) : (true))
        {
            Session::flash('error', "Curso não encontrado!");

            return redirect()->route('catalogo');
        }

        if($curso->status != 1)
        {
            if(Auth::check() ? (strtoupper(Auth::user()->permissao) != "Z" && $curso->user_id != Auth::user()->id) : true)
            {
                Session::flash('error', "Curso não encontrado!");

                return redirect()->route('catalogo');
            }
            else
            {
                Session::flash('previewMode', true);
            }
        }

        if(Session::has('senhaCurso'. $curso->id))
        {
            if(Session::get('senhaCurso'. $curso->id) == $curso->senha)
            {
                if($curso->escola_id != 1 && \App\Escola::find($curso->escola_id) != null)
                {
                    return redirect()->route('curso', ['escola_id' => \App\Escola::find($curso->escola_id)->url, 'idCurso' => $idCurso]);
                }
                else
                {
                    return redirect()->route('curso', ['idCurso' => $idCurso]);
                }

            }
            else
            {
                Session::forget('senhaCurso'. $curso->id);
            }
        }

        return view('curso.trancado')->with(compact('curso'));
    }

    public function postAcessarCursoTrancado($idCurso, Request $request)
    {
        if(is_numeric($idCurso))
        {
            if(Curso::find($idCurso) != null)
            {
                $curso = Curso::with('aulas', 'user', 'avaliacoes_user')->find($idCurso);
            }
        }
        else
        {
            if(Curso::where('titulo', '=', str_replace('-', ' ', $idCurso))->first() != null)
            {
                $curso = Curso::with('aulas', 'user', 'avaliacoes_user')->where('titulo', '=', str_replace('-', ' ', $idCurso))->first();
            }
            elseif(is_numeric( substr(strrchr($idCurso, "-"), 1) ))
            {
                if(Curso::find(substr(strrchr($idCurso, "-"), 1)) != null)
                {
                    $temp = Curso::find(substr(strrchr($idCurso, "-"), 1));

                    $tempTitulo = mb_strtolower(str_replace(' ', '-', $temp->titulo) . '-' . $temp->id, 'utf-8');

                    if($tempTitulo == $idCurso)
                    {
                        $curso = Curso::find(substr(strrchr($idCurso, "-"), 1));
                    }
                }
            }
        }

        if(isset($curso) ? ($curso == null) : (true))
        {
            Session::flash('error', "Curso não encontrado!");

            return redirect()->route('catalogo');
        }

        if($curso->status != 1)
        {
            if(Auth::check() ? (strtolower(Auth::user()->permissao) != "z" && $curso->user_id != Auth::user()->id) : true)
            {
                Session::flash('error', "Curso não encontrado!");

                return redirect()->route('catalogo');
            }
            else
            {
                Session::flash('previewMode', true);
            }
        }

        if($request->senha == $curso->senha)
        {
            Session::put('senhaCurso'. $curso->id, $request->senha);

            if($curso->escola_id != 1 && \App\Escola::find($curso->escola_id) != null)
            {
                return redirect()->route('curso', ['escola_id' => \App\Escola::find($curso->escola_id)->url, 'idCurso' => $idCurso]);
            }
            else
            {
                return redirect()->route('curso', ['idCurso' => $idCurso]);
            }
        }
        else
        {
            return Redirect::back()->withErrors(['Senha do curso inválida!']);
        }
    }

    function checkoutCurso($idCurso)
    {
        if(Curso::find($idCurso))
        {
            $curso = Curso::with('user')->where('id', '=', $idCurso)->get()->first();
        }
        else
        {
            return Redirect::back()->withErrors(['Curso não encontrado!']);
        }

        if($curso->status == 0)
        {
            Session::flash('error', "Curso não encontrado!");

            return redirect()->route('catalogo');
        }

        $produto = (object) [
            'id' => $idCurso,
            'preco' => $curso->preco,
            'titulo' => ucfirst($curso->titulo),
            "descricao" => substr(ucfirst($curso->descricao), 0, 50) . '.',
            "tipo" => 2,
            "transacoes" => null,
            "referencia" => null,
            "quantidade" => null,
            "recorrencia" => null,
        ];

        Session::put('carrinho', [$produto]);

        $total = 0;

        $produto->curso = Curso::find($idCurso);

        $produto->transacoes = collect();

        foreach (ProdutoTransacao::where([['user_id', '=', Auth::user()->id], ['produto_id', '=', $curso->id]])->get() as $prod)
        {
            if(Transacao::where([['referencia_id', '=', $prod->transacao_id], ['status', '<', 5]])->first() != null)
            {
                $produto->transacoes->push(Transacao::where([['referencia_id', '=', $prod->transacao_id], ['status', '<', 5]])->first());
            }
        }

        $produto->transacoes = $produto->transacoes->unique(function ($item) {
            return $item->id;
        });

        if(count($produto->transacoes) > 0)
        {
            Session::put('carrinho', []);

            return redirect()->route('curso', ['idCurso' => $produto->id]);
        }

        $total += $produto->preco;

        if($total == 0)
        {
            return redirect()->route('curso.matricular', ['idCurso' => $produto->id]);
        }

        // dd($curso);

        // return view('checkout')->with(compact('cursos', 'total'));
        return redirect()->route('wirecard.checkout');
    }

    public function cursoCarrinho($idCurso, Request $request)
    {
        if(is_numeric($idCurso))
        {
            if(Curso::find($idCurso) != null)
            {
                $curso = Curso::find($idCurso);
            }
            else
            {
                Session::flash('error', "Curso não encontrado!");

                return redirect()->route('catalogo');
            }
        }
        else
        {
            if(Curso::where('titulo', '=', str_replace('-', ' ', $idCurso))->first() != null)
            {
                $curso = Curso::where('titulo', '=', str_replace('-', ' ', $idCurso))->first();
            }
            else
            {
                Session::flash('error', "Curso não encontrado!");

                return redirect()->route('catalogo');
            }
        }

        if($curso->status == 0)
        {
            Session::flash('error', "Curso não encontrado!");

            return redirect()->route('catalogo');
        }

        $produto = (object) [
            'id' => $idCurso,
            'preco' => $curso->preco,
            'titulo' => ucfirst($curso->titulo),
            "descricao" => substr(ucfirst($curso->descricao), 0, 50) . '.',
            "tipo" => 2,
            "curso" => $curso,
            "transacoes" => null,
            "referencia" => null,
            "quantidade" => null,
            "recorrencia" => null,
        ];

        if(Session::has('carrinho'))
        {
            $carrinho = Session::get('carrinho');

            if(array_search($idCurso, array_column($carrinho, 'id')) === false)
            {
                array_push($carrinho, $produto);

                Session::put('carrinho', $carrinho);
            }
            else
            {
                Session::flash('message', "Este produto já está em seu carrinho!");
            }
        }
        else
        {
            Session::put('carrinho', [$produto]);
        }

        // Session::flash('message', "Curso adicionado ao carrinho!");

        if($request->return != "")
        {
            return redirect($request->return);
        }

        return redirect()->route('carrinho.index');
    }

    public function matricular($idCurso)
    {
        if(is_numeric($idCurso))
        {
            if(Curso::find($idCurso) != null)
            {
                $curso = Curso::find($idCurso);
            }
            else
            {
                Session::flash('error', "Curso não encontrado!");

                return redirect()->route('catalogo');
            }
        }
        else
        {
            if(Curso::where('titulo', '=', str_replace('-', ' ', $idCurso))->first() != null)
            {
                $curso = Curso::where('titulo', '=', str_replace('-', ' ', $idCurso))->first();
            }
            else
            {
                Session::flash('error', "Curso não encontrado!");

                return redirect()->route('catalogo');
            }
        }

        if($curso->status != 1)
        {
            if(Auth::check() ? (strtolower(Auth::user()->permissao) != "z" && $curso->user_id != Auth::user()->id) : true)
            {
                Session::flash('error', "Curso não encontrado!");

                return redirect()->route('catalogo');
            }
            else
            {
                Session::flash('previewMode', true);
            }
        }

        if(Matricula::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $curso->id]])->first() != null)
        {
            if(\App\Escola::find($curso->escola_id) != null)
            {
                return redirect()->route('curso.play', ['escola_id' => \App\Escola::find($curso->escola_id)->url, 'idCurso' => $curso->id]);
            }
            else
            {
                return redirect()->route('curso.play', ['idCurso' => $curso->id]);
            }
        }

        if($curso->preco > 0 && (Auth::check() ? (strtoupper(Auth::user()->permissao) != "Z" && $curso->user_id != Auth::user()->id) : true))
        {
            $curso->transacoes = collect();

            $curso->pago = false;

            foreach (ProdutoTransacao::where([['user_id', '=', Auth::user()->id], ['produto_id', '=', $curso->id]])->get() as $produto)
            {
                if(Transacao::where([['referencia_id', '=', $produto->transacao_id], ['status', '<', 5]])->first() != null)
                {
                    $curso->transacoes->push(Transacao::where([['referencia_id', '=', $produto->transacao_id], ['status', '<', 5]])->first());
                }

                if(Transacao::where([['referencia_id', '=', $produto->transacao_id], ['status', '=', 3]])->orWhere([['id', '=', $produto->transacao_id], ['status', '=', 4]])->first() != null)
                {
                    $curso->pago = true;
                }
            }

            $curso->transacoes = $curso->transacoes->unique(function ($item) {
                return $item->id;
            });

            if(count($curso->transacoes) == 0)
            {
                return redirect()->route('checkout');
                // return redirect()->route('curso.checkout', ['idCurso' => $curso->id]);
            }
            else
            {
                if($curso->pago)
                {
                    Matricula::create([
                        'user_id' => Auth::user()->id,
                        'curso_id' => $curso->id,
                    ]);

                    if(\App\Escola::find($curso->escola_id) != null)
                    {
                        return redirect()->route('curso.play', ['escola_id' => \App\Escola::find($curso->escola_id)->url, 'idCurso' => $curso->id]);
                    }
                    else
                    {
                        return redirect()->route('curso.play', ['idCurso' => $curso->id]);
                    }
                }
                else
                {
                    if(\App\Escola::find($curso->escola_id) != null)
                    {
                        return redirect()->route('curso', ['escola_id' => \App\Escola::find($curso->escola_id)->url, 'idCurso' => $curso->id]);
                    }
                    else
                    {
                        return redirect()->route('curso', ['idCurso' => $curso->id]);
                    }
                }
            }
        }
        else
        {
            Matricula::create([
                'user_id' => Auth::user()->id,
                'curso_id' => $curso->id,
            ]);

            if(\App\Escola::find($curso->escola_id) != null)
            {
                return redirect()->route('curso.play', ['escola_id' => \App\Escola::find($curso->escola_id)->url, 'idCurso' => $curso->id]);
            }
            else
            {
                return redirect()->route('curso.play', ['idCurso' => $curso->id]);
            }
        }
    }

    public function playCurso($idCurso)
    {
        $curso = null;

        if(is_numeric($idCurso))
        {
            if(Curso::find($idCurso) != null)
            {
                $curso = Curso::with('aulas', 'user', 'avaliacoes_user')->where([['id', '=', $idCurso]])->first();
            }
        }
        else
        {
            if(Curso::where('titulo', '=', $idCurso)->first() != null)
            {
                $curso = Curso::with('aulas', 'user', 'avaliacoes_user')->where([['titulo', '=', $idCurso]])->first();
            }
            elseif(is_numeric( substr(strrchr($idCurso, "-"), 1) ))
            {
                if(Curso::find(substr(strrchr($idCurso, "-"), 1)) != null)
                {
                    $temp = Curso::find(substr(strrchr($idCurso, "-"), 1));

                    $tempTitulo = mb_strtolower($temp->titulo . '-' . $temp->id, 'utf-8');

                    if($tempTitulo == $idCurso)
                    {
                        $curso = Curso::find(substr(strrchr($idCurso, "-"), 1));
                    }
                }
            }
        }

        if($curso == null)
        {
            return Redirect::back()->withErrors(['Curso não encontrado!']);
        }

        // if(Curso::find($curso->id))
        // {
        //     $curso = Curso::with('aulas')->find($curso->id);
        // }
        // else
        // {
        //     return Redirect::back()->withErrors(['Curso não encontrado!']);
        // }

        if($curso->status != 1)
        {
            if(Auth::check() ? (strtolower(Auth::user()->permissao) != "z" && $curso->user_id != Auth::user()->id) : true)
            {
                return Redirect::back()->withErrors(['Curso não encontrado!']);
            }
            else
            {
                Session::flash('previewMode', true);
            }
        }

        if(Matricula::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $curso->id]])->first() == null)
        {
            return redirect()->route('curso.matricular', ['idCurso' => $curso->id]);
        }

        if(count($curso->aulas) == 0)
        {
            return Redirect::back()->withErrors(['Este curso ainda não possui nenhuma aula!']);
        }

        $conteudosCompletos = 0;

        foreach ($curso->aulas as $key => $aula)
        {
            // $aula->conteudos = Conteudo::where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]])->orderBy('ordem')->get();
            $aula->conteudos = Conteudo::with('conteudos_aula')
            ->whereHas('conteudos_aula', function ($query) use ($curso, $aula) {
                $query->where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]]);
            })
            // ->orderBy('ordem', 'asc')
            ->get()
            ->sortBy('conteudos_aula.ordem');

            // dd($aula->conteudos);

            $aula->conteudos = Conteudo::detalhado($aula->conteudos);

            $conteudosCompletos = 0;

            foreach ($aula->conteudos as $conteudo)
            {
                $conteudo->conteudo_completo = ConteudoCompleto::where([['conteudo_id', '=', $conteudo->id], ['aula_id', '=', $aula->id], ['curso_id', '=', $curso->id], ['user_id', '=', Auth::user()->id]])->first();

                $conteudo->correto = null;

                if($conteudo->conteudo_completo != null)
                    $conteudosCompletos ++;

                if($conteudo->tipo == 8)
                {
                    $tempCont = json_decode($conteudo->conteudo);

                    if($conteudo->conteudo_completo != null)
                    if($tempCont->correta == ConteudoCompleto::where([['conteudo_id', '=', $conteudo->id], ['aula_id', '=', $aula->id], ['curso_id', '=', $curso->id], ['user_id', '=', Auth::user()->id]])->first()->resposta)
                    {
                        $conteudo->correto = true;
                    }
                    else
                    {
                        $conteudo->correto = false;

                        $conteudosCompletos --;
                    }
                }
                elseif($conteudo->tipo == 7 || $conteudo->tipo == 10)
                {
                    if($conteudo->conteudo_completo != null)
                    if(ConteudoCompleto::where([['conteudo_id', '=', $conteudo->id], ['aula_id', '=', $aula->id], ['curso_id', '=', $curso->id], ['user_id', '=', Auth::user()->id]])->first()->correta === "1")
                    {
                        $conteudo->correto = true;
                    }
                    elseif(ConteudoCompleto::where([['conteudo_id', '=', $conteudo->id], ['aula_id', '=', $aula->id], ['curso_id', '=', $curso->id], ['user_id', '=', Auth::user()->id]])->first()->correta === "0")
                    {
                        $conteudo->correto = false;

                        $conteudosCompletos --;
                    }
                }
            }

            if($conteudosCompletos == count($aula->conteudos))
            {
                $aula->completa = true;
            }
            else
            {
                $aula->completa = false;
            }
        }

        $avaliouCurso = (AvaliacaoCurso::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $curso->id]])->first() != null);
        $avaliouProfessor = (AvaliacaoInstrutor::where([['user_id', '=', Auth::user()->id], ['instrutor_id', '=', $curso->user_id]])->first() != null);
        $avaliouEscola = (AvaliacaoEscola::where([['user_id', '=', Auth::user()->id], ['escola_id', '=', $curso->escola_id]])->first() != null);

        // if($conteudosCompletos >= Conteudo::where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]])->count())
        if($conteudosCompletos >= Conteudo::
        // whereHas('conteudo_aula', function ($query) use ($curso, $aula) {
        //     $query->where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]]);
        // })
        whereHas('conteudo_aula', function ($query) use ($curso) {
            $query->where([['curso_id', '=', $curso->id]]);
        })
        ->count())
        {
            $curso->completo = true;
        }
        else
        {
            $curso->completo = false;
        }

        $qtAulas = Aula::where('curso_id', '=', $curso->id)->count();

        if($curso->completo)
        {
            $ultimaAula = 0;
            $ultimoConteudo = 0;
        }
        else
        {
            foreach (Aula::where('curso_id', '=', $curso->id)->orderBy('id', 'asc')->get() as $key => $aula)
            {
                // $totalConteudosCurso = Conteudo::where([['curso_id', '=', $curso->id], ['obrigatorio', '=', '1'], ['aula_id', '=', $aula->id]])->count();
                $totalConteudosCurso = Conteudo::whereHas('conteudo_aula', function ($query) use ($curso, $aula) {
                    $query->where([['curso_id', '=', $curso->id], ['obrigatorio', '=', '1'], ['aula_id', '=', $aula->id]]);
                })->count();

                if(ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]])->count() >= $totalConteudosCurso)
                {
                    continue;
                }
                else
                {
                    if(\Request::has('aula') ? Aula::where([['curso_id', '=', $curso->id], ['id', '=', \Request::get('aula')]])->exists() : false)
                        $ultimaAula = \Request::get('aula');
                    else
                        $ultimaAula = $aula->id;

                    // $conteudos_curso = Conteudo::where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]])->orderBy('ordem', 'asc')->get();

                    $conteudos_curso = Conteudo::with('conteudos_aula')->whereHas('conteudos_aula', function ($query) use ($curso, $aula) {
                        $query->where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]]);
                    })
                    ->get()
                    ->sortBy('conteudos_aula.ordem');

                    foreach ($conteudos_curso as $key2 => $conteudo)
                    {
                        if(ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id], ['conteudo_id', '=', $conteudo->id]])->first() != null)
                        {
                            continue;
                        }
                        else
                        {
                            if(\Request::has('conteudo'))
                            {
                                // $tem_conteudo = ConteudoAula::where([['curso_id', '=', $curso->id], ['aula_id', '=', $ultimaAula], ['id', '=', \Request::get('conteudo')]])->exists();
                                $tem_conteudo = ConteudoAula::where([['curso_id', '=', $curso->id], ['aula_id', '=', $ultimaAula], ['conteudo_id', '=', \Request::get('conteudo')]])->exists();

                                if($tem_conteudo)
                                {
                                    $ultimoConteudo = \Request::get('conteudo');
                                }
                                else
                                {
                                    $ultimoConteudo = $conteudo->id;
                                }
                            }
                            else
                            {
                                $ultimoConteudo = $conteudo->id;
                            }


                            // $qtConteudos = Conteudo::where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]])->orderBy('ordem', 'asc')->count();
                            $qtConteudos = Conteudo::with('conteudos_aula')->whereHas('conteudos_aula', function ($query) use ($curso, $aula) {
                                $query->where([['curso_id', '=', $curso->id], ['aula_id', '=', $aula->id]]);
                            })->count();

                            break;
                        }
                    }

                    break;
                }
            }
        }

        // dd($curso);

        return view('play.curso')->with(compact('curso', 'ultimaAula', 'ultimoConteudo', 'avaliouCurso', 'avaliouProfessor', 'avaliouEscola'));
    }

    function checkMatricula($idCurso)
    {
        if(Curso::find($idCurso))
        {
            $curso = Curso::with('aulas')->find($idCurso);
        }
        else
        {
            return response()->json(['error' => 'Curso não encontrado']);
        }

        if(Matricula::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $curso->id]])->first() == null)
        {
            return response()->json(['error' => 'Matricula não encontrada']);
        }
    }

    function playGetAula($idCurso, $idAula)
    {
        $this->checkMatricula($idCurso);

        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            $aula = Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first()->withConteudos();

            return response()->json(['success'=> 'Aula encontrada.', 'aula' => json_encode($aula)]);
        }
        else
        {
            return response()->json(['error' => 'Não encontrado']);
        }
    }


    function playGetConteudo($idCurso, $idAula, $idConteudo)
    {
        $this->checkMatricula($idCurso);

        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            $aula = Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first();

            // if(Conteudo::where([['id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
            if(Conteudo::where([['id', '=', $idConteudo]])->first() != null)
            {
                $aula->conteudo = Conteudo::where([['id', '=', $idConteudo]])->first();

                $aula->conteudo->completo = false;

                if(ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first() != null)
                {
                    $aula->conteudo->completo = true;
                    $resposta = ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first()->resposta;
                }

                if($aula->conteudo->tipo == 2)
                {
                    if(strpos($aula->conteudo->conteudo, "soundcloud.com") !== false)
                    {
                        $aula->conteudo->conteudo = '<iframe width="100%" height="166" scrolling="no" frameborder="no" allow="autoplay" src="https://w.soundcloud.com/player/?url=' . $aula->conteudo->conteudo . '&color=%236766a6&auto_play=false&hide_related=false&show_comments=true&show_user=true&show_reposts=false&show_teaser=true"></iframe>';
                    }
                    elseif(strpos($aula->conteudo->conteudo, "http") !== false || strpos($aula->conteudo->conteudo, "www") !== false)
                    {
                        $aula->conteudo->conteudo = '<audio id="player" controls style="width: 100%;">
                            <source src="' . $aula->conteudo->conteudo . '" type="audio/mp3">
                            Your browser does not support the audio element.
                        </audio>';

                        // Insert plyr script tag
                        $aula->conteudo->conteudo = $aula->conteudo->conteudo . '<script>
                            if(player != undefined)
                                player = new Plyr(\'#player\');
                            else
                                player = new Plyr(\'#player\');
                        </script>';
                    }
                    else
                    {
                        $aula->conteudo->conteudo = '<audio id="player" controls style="width: 100%;">
                            <source src="' . route('curso.play.get-arquivo', ['idCurso' => $idCurso, 'idAula' => $idAula, 'idConteudo' => $idConteudo]) . '" type="audio/mp3">
                            Your browser does not support the audio element.
                        </audio>';

                        // Insert plyr script tag
                        $aula->conteudo->conteudo = $aula->conteudo->conteudo . '<script>
                            if(player != undefined)
                                player = new Plyr(\'#player\');
                            else
                                player = new Plyr(\'#player\');
                        </script>';
                    }

                }
                else if($aula->conteudo->tipo == 3)
                {
                    // if(strpos($aula->conteudo->conteudo, "www") === false && strpos($aula->conteudo->conteudo, "http") === false)
                    // {
                    //     $filePath = 'uploads/cursos/' . $idCurso . '/arquivos/' . $aula->conteudo->conteudo;

                    //     if(\Storage::disk('gcs')->exists($filePath))
                    //     {
                    //         if(\Storage::disk('gcs')->getVisibility($filePath) == 'public')
                    //         {
                    //             \Storage::disk('gcs')->setVisibility($filePath, 'private');
                    //         }

                    //         $aula->conteudo->conteudo = \Storage::disk('gcs')->getAdapter()->getBucket()->object($filePath)->signedUrl(now()->addSeconds(120));

                    //         // $aula->conteudo->conteudo = \Storage::disk('gcs')->url($filePath);
                    //     }
                    // }

                    if(strpos($aula->conteudo->conteudo, "youtube") !== false || strpos($aula->conteudo->conteudo, "youtu.be") !== false)
                    {
                        if(strpos($aula->conteudo->conteudo, "youtu.be") !== false)
                        {
                            $aula->conteudo->conteudo = str_replace("youtu.be", "youtube.com/embed/", $aula->conteudo->conteudo);
                        }

                        if(strpos($aula->conteudo->conteudo, "/embed/") === false)
                        {
                            $aula->conteudo->conteudo = str_replace("/watch?v=", "/embed/", $aula->conteudo->conteudo);
                        }

                        if(strpos($aula->conteudo->conteudo, "&") !== false)
                        {
                            $aula->conteudo->conteudo = substr($aula->conteudo->conteudo, 0, strpos($aula->conteudo->conteudo, "&"));
                        }

                        $aula->conteudo->conteudo = '<iframe src="' . $aula->conteudo->conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                        </iframe>';

                    }
                    elseif(strpos($aula->conteudo->conteudo, "fast.player.liquidplatform.com") !== false)
                    {

                        $aula->conteudo->conteudo = '<iframe src="' . $aula->conteudo->conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                        </iframe>';

                    }
                    elseif(strpos($aula->conteudo->conteudo, "vimeo") !== false)
                    {
                        if(strpos($aula->conteudo->conteudo, "player.vimeo.com") === false)
                        {
                            // $aula->conteudo->conteudo = str_replace("vimeo.com/", "player.vimeo.com/video/", $aula->conteudo->conteudo);
                            $aula->conteudo->conteudo = str_replace("vimeo.com/", "", $aula->conteudo->conteudo);
                            $aula->conteudo->conteudo = str_replace("player.vimeo.com/video/", "", $aula->conteudo->conteudo);
                            $aula->conteudo->conteudo = str_replace("https://", "", $aula->conteudo->conteudo);
                            $aula->conteudo->conteudo = str_replace("http://", "", $aula->conteudo->conteudo);
                            $aula->conteudo->conteudo = str_replace("www.", "", $aula->conteudo->conteudo);

                            if(substr_count($aula->conteudo->conteudo, '/') > 0)
                            {
                                $aula->conteudo->conteudo = substr($aula->conteudo->conteudo, 0, strrpos($aula->conteudo->conteudo, '/'));
                            }

                            $aula->conteudo->conteudo = 'https://player.vimeo.com/video/' . $aula->conteudo->conteudo;
                        }

                        $aula->conteudo->conteudo = '<iframe src="' . $aula->conteudo->conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen>
                        </iframe>';
                    }
                    elseif(strpos($aula->conteudo->conteudo, "http") !== false || strpos($aula->conteudo->conteudo, "www") !== false)
                    {
                        $aula->conteudo->conteudo = '<video id="player" controls style="width: 100%; height: 41vw;">
                            <source src="' . $aula->conteudo->conteudo . '" type="video/mp4">
                            Your browser does not support the video element.
                        </video>';

                        // Insert plyr script tag
                        $aula->conteudo->conteudo = $aula->conteudo->conteudo . '<script>
                            if(player != undefined)
                                player = new Plyr(\'#player\');
                            else
                                player = new Plyr(\'#player\');
                        </script>';
                    }
                    else
                    {
                        $aula->conteudo->conteudo = '<video id="player" controls style="width: 100%; height: 41vw;">
                            <source src="' . route('curso.play.get-arquivo', ['idCurso' => $idCurso, 'idAula' => $idAula, 'idConteudo' => $idConteudo]) . '" type="video/mp4">
                            Your browser does not support the video element.
                        </video>';

                        // Insert plyr script tag
                        $aula->conteudo->conteudo = $aula->conteudo->conteudo . '<script>
                            if(player != undefined)
                                player = new Plyr(\'#player\');
                            else
                                player = new Plyr(\'#player\');
                        </script>';
                    }
                }
                else if($aula->conteudo->tipo == 4)
                {
                    if(strpos($aula->conteudo->conteudo, "http") === false && strpos($aula->conteudo->conteudo, "www") === false)
                    {
                        $url_conteudo = route('conteudo.play.get-arquivo', ['idConteudo' => $idConteudo]);
                    }
                    else
                    {
                        $url_conteudo = $aula->conteudo->conteudo;
                    }

                    if (strpos($aula->conteudo->conteudo, ".ppt") !== false || strpos($aula->conteudo->conteudo, ".pptx") !== false)
                    {
                        $aula->conteudo->conteudo = '<iframe src="https://view.officeapps.live.com/op/view.aspx?src=' . $url_conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                        </iframe>';
                    }
                    elseif (strpos($aula->conteudo->conteudo, ".html") !== false)
                    {
                        $aula->conteudo->conteudo = '<iframe src="' . $url_conteudo . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                        </iframe>';
                    }
                    else
                    {
                        $aula->conteudo->conteudo = '<object data="' . $url_conteudo . '" type="application/pdf" style="width: 100%; height: 41vw;">
                        </object>';
                    }

                    // if(strpos($aula->conteudo->conteudo, ".ppt") !== false)
                    // {
                    //     $aula->conteudo->conteudo = '<iframe src="https://view.officeapps.live.com/op/view.aspx?src=' . route('curso.play.get-arquivo', ['idCurso' => $idCurso, 'idAula' => $idAula, 'idConteudo' => $idConteudo]) . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                    //     </iframe>';
                    // }
                    // elseif(strpos($aula->conteudo->conteudo, ".html") !== false)
                    // {
                    //     // $aula->conteudo->conteudo = '<iframe src="http://docs.google.com/gview?url=' . route('curso.play.get-arquivo', ['idCurso' => $idCurso, 'idAula' => $idAula, 'idConteudo' => $idConteudo]) . '&embedded=true" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                    //     // </iframe>';
                    //     $aula->conteudo->conteudo = '<iframe src="' . route('curso.play.get-arquivo', ['idCurso' => $idCurso, 'idAula' => $idAula, 'idConteudo' => $idConteudo]) . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                    //     </iframe>';
                    // }
                    // else
                    // {
                    //     $aula->conteudo->conteudo = '<object data="' . route('curso.play.get-arquivo', ['idCurso' => $idCurso, 'idAula' => $idAula, 'idConteudo' => $idConteudo]) . '" type="application/pdf" style="width: 100%; height: 41vw;">
                    //     </object>';
                    // }

                }
                else if($aula->conteudo->tipo == 5)
                {
                    $mensagensTransmissao = '';

                    foreach (MensagemTransmissao::with('user')->where([['curso_id', '=', $idCurso], ['aula_id', '=', $idAula], ['conteudo_id', '=', $idConteudo]])->orderBy('created_at', 'asc')->get() as $mensagem)
                    {
                        $mensagensTransmissao = $mensagensTransmissao . '<div id="divMensagem' . $mensagem->id . '" style="font-size: 1vw/*18px*/;color:  #BCBCBC;max-width: 100%;padding:  12px 8px;">
                            <div style="display: inline-block;border: 2px solid #207adc;vertical-align: middle;margin: 0px;background: url(' . route('usuario.perfil.image', [$mensagem->user->id]) . ');width: 45px;height: 45px;background-size: cover !important;background-repeat: no-repeat !important;background-position: 50% 50% !important;border-radius: 50%;margin-right:  8px;">
                            </div>
                            <div style="vertical-align:  middle;display:  inline-block;max-width: calc(100% - 58px);text-align:  -webkit-left;color: #207adc;font-weight: bold;">
                                ' . ucfirst($mensagem->user->name) . ':
                                <span style="color: #354353;">
                                    ' . $mensagem->mensagem . '
                                </span>
                            </div>
                        </div>';
                    }

                    $aula->conteudo->conteudo = '<video id="my_video_1" class="video-js vjs-default-skin" controls preload="auto" style="width: 70%; height: 41vw; display: inline-block;"
                    data-setup="">
                      <source src="' . $aula->conteudo->conteudo . '" type="application/x-mpegURL">
                    </video>
                    <div id="divMainChat" style="display:  inline-block;width: calc( 30% - 10px);vertical-align: top;text-align:  -webkit-center;height: 41vw;position: relative;transition: all .3s ease-in-out;">
                        <div style="width:  100%;height:  100%;background-color: #F9F9F9;">
                            <div style="padding: 14px 4px;color: white;font-size: 1.2vw;background-color: #008CC8;max-height: 51px;overflow: hidden;text-overflow:  ellipsis;white-space:  nowrap;text-transform:  uppercase;">
                                Chat de transmissão ao vivo
                            </div>
                            <div id="divConteudoMensagens" style="text-align:  -webkit-left;height: calc( 92% - 52px);overflow: auto;">
                                ' . $mensagensTransmissao . '
                            </div>
                            <div class="msb-reply" style="display: block;height: 8%;position: relative;border-top: 1px solid #eee;background: #F3F3F3;margin:  0px;box-shadow:  none;">
                                <textarea id="txtConteudoMensagem" placeholder="Envie uma mensagem." onkeyup="if(event.keyCode == 13 &amp;&amp; !event.shiftKey){enviarMensagemChatTransmissao();};" style="width: calc(100% - 50px);min-height: 10px;max-height: 100%;border: 0;padding: 10px 15px;resize: none;height: 60px;background: 0 0;font-size:  16px;vertical-align: middle;"></textarea>
                                <button class="btn bg-transparent border-0" onclick="enviarMensagemChatTransmissao();" style="color: #008CC8;vertical-align:middle;"><i class="fas fa-paper-plane"></i></button>
                            </div>
                        </div>
                    </div>
                    <script>
                        var player = videojs("my_video_1");
                        timestamp = "' . strtotime(date('Y-m-d H:i:s')) . '";
                    </script>';
                }
                else if($aula->conteudo->tipo == 6)
                {
                    $aula->conteudo->conteudo = '<div>
                        <h4>' . ucfirst($aula->conteudo->titulo) . '</h4>
                        <p>' . ucfirst($aula->conteudo->descricao) . '</p>
                        <a href="' . route('curso.play.get-arquivo', ['idCurso' => $idCurso, 'idAula' => $idAula, 'idConteudo' => $idConteudo]) . '" target="_blank" class="btn btn-primary btn-lg">
                            <i class="fas fa-arrow-alt-circle-down mr-2"></i>
                            Clique para baixar o arquivo
                        </a>
                    </div>';
                }
                else if($aula->conteudo->tipo == 7)
                {
                    $tempCont = json_decode($aula->conteudo->conteudo);

                    if($aula->conteudo->completo)
                    {
                        if(ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first()->correta == "1")
                        {
                            $aula->conteudo->correto = true;
                        }
                        elseif(ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first()->correta == "0")
                        {
                            $aula->conteudo->correto = false;
                        }
                        else
                        {
                            $aula->conteudo->correto = null;
                        }
                    }
                    else
                    {

                        $aula->conteudo->correto = null;
                    }

                    $aula->conteudo->conteudo = '<div class="px-3 py-2">
                        <h2>' . ucfirst($tempCont->pergunta) . '</h2>';

                    if($aula->conteudo->completo != null)
                    {
                        if($aula->conteudo->correto != null)
                        {
                            $aula->conteudo->conteudo = $aula->conteudo->conteudo . '
                            <div id="boxResposta" class="box-alternativa box-shadow px-4 py-4 rounded-10 my-3 ' . ($aula->conteudo->correto ? 'alternativa-correta' : 'alternativa-incorreta') . '">
                                <div class="form-group mb-3 text-left">
                                    <textarea class="form-control" name="resposta" id="txtRespostaDissertativa" rows="3" placeholder="Clique para digitar sua resposta.">' . $resposta . '</textarea>
                                </div>
                            </div>';
                        }
                        else
                        {
                            $aula->conteudo->conteudo = $aula->conteudo->conteudo . '
                            <div id="boxResposta" class="box-alternativa box-shadow px-4 py-4 rounded-10 my-3">
                                <div class="form-group mb-3 text-left">
                                    <textarea class="form-control" name="resposta" id="txtRespostaDissertativa" rows="3" placeholder="Clique para digitar sua resposta." readonly>' . $resposta . '</textarea>
                                </div>
                            </div>';
                        }
                    }
                    else
                    {
                        $aula->conteudo->conteudo = $aula->conteudo->conteudo . '
                        <div id="boxResposta" class="box-alternativa box-shadow px-4 py-4 rounded-10 my-3">
                            <div class="form-group mb-3 text-left">
                                <textarea class="form-control" name="resposta" id="txtRespostaDissertativa" rows="3" placeholder="Clique para digitar sua resposta."></textarea>
                            </div>
                        </div>';
                    }

                    if($aula->conteudo->correto === null)
                    {
                        $aula->conteudo->conteudo .= '
                        <div id="divAguardandoCorrecao" class="p-3 ' . ($aula->conteudo->completo ? '' : 'd-none') . '">
                            <h4>
                                <i class="fas fa-clock fa-fw mr-2 fa-lg"></i>
                                Aguardando correção do professor.' . $aula->conteudo->correto .'
                            </h4>
                        </div>
                        <div id="divRespostaCorreta" class="p-3 d-none">
                            <h4 style="color: #008CC8;">
                                <i class="fas fa-check fa-fw mr-2 fa-lg"></i>
                                Parabéns, você acertou!
                            </h4>
                        </div>
                        <div id="divRespostaIncorreta" class="p-3 d-none">
                            <h4 style="color: #ee9164;">
                                <i class="fas fa-times fa-fw mr-2 fa-lg"></i>
                                Que pena, você não acertou! Tente novamente.
                            </h4>
                        </div>';

                        $aula->conteudo->conteudo .= '
                            <div class="text-right">
                                <button id="btnConfirmarResposta" type="button" onclick="confirmarResposta();" class="btn bg-bluelight btn-lg py-2 px-4 rounded-10 text-uppercase font-weight-bold text-truncate col-12 col-sm-auto ' . ($aula->conteudo->completo ? 'd-none' : '') . '" style="color: #525870; border: 3px solid #008cc8;">
                                    Confirmar
                                </button>
                                <button id="btnTentarNovamente" type="button" onclick="tentarNovamente();" class="btn bg-bluelight btn-lg py-2 px-4 rounded-10 text-uppercase font-weight-bold text-truncate col-12 col-sm-auto d-none" style="color: #525870; border: 3px solid #008cc8;">
                                    Tentar novamente
                                </button>
                            </div>
                        </div>';
                    }
                    else
                    {
                        $aula->conteudo->conteudo .= '
                        <div id="divAguardandoCorrecao" class="p-3 d-none">
                            <h4>
                                <i class="fas fa-clock fa-fw mr-2 fa-lg"></i>
                                Aguardando correção do professor.
                            </h4>
                        </div>
                        <div id="divRespostaCorreta" class="p-3 ' . ($aula->conteudo->correto ? '' : 'd-none') . '">
                            <h4 style="color: #008CC8;">
                                <i class="fas fa-check fa-fw mr-2 fa-lg"></i>
                                Parabéns, você acertou!
                            </h4>
                        </div>
                        <div id="divRespostaIncorreta" class="p-3 ' . ($aula->conteudo->correto ? 'd-none' : '') . '">
                            <h4 style="color: #ee9164;">
                                <i class="fas fa-times fa-fw mr-2 fa-lg"></i>
                                Que pena, você não acertou! Tente novamente.
                            </h4>
                        </div>';

                        $aula->conteudo->conteudo .= '
                            <div class="text-right">
                                <button id="btnConfirmarResposta" type="button" onclick="confirmarResposta();" class="btn bg-bluelight btn-lg py-2 px-4 rounded-10 text-uppercase font-weight-bold text-truncate col-12 col-sm-auto ' . ($aula->conteudo->completo ? 'd-none' : '') . '" style="color: #525870; border: 3px solid #008cc8;">
                                    Confirmar
                                </button>
                                <button id="btnTentarNovamente" type="button" onclick="tentarNovamente();" class="btn bg-bluelight btn-lg py-2 px-4 rounded-10 text-uppercase font-weight-bold text-truncate col-12 col-sm-auto ' . ($aula->conteudo->completo == false ? 'd-none' : '') . ($aula->conteudo->correto == true ? 'd-none' : '') . '" style="color: #525870; border: 3px solid #008cc8;">
                                    Tentar novamente
                                </button>
                            </div>
                        </div>';
                    }

                }
                else if($aula->conteudo->tipo == 8)
                {
                    $tempCont = json_decode($aula->conteudo->conteudo);

                    if($aula->conteudo->completo)
                    {
                        $aula->conteudo->correto = ($tempCont->correta == $resposta);
                    }
                    else
                    {
                        $aula->conteudo->correto = null;
                    }

                    $aula->conteudo->conteudo = '<div class="px-3 py-2">
                        <h2>' . ucfirst($tempCont->pergunta) . '</h2>';

                    foreach ($tempCont->alternativas as $key => $alternativa)
                    {
                        $aula->conteudo->conteudo = $aula->conteudo->conteudo . '
                        <div id="boxAlternativa' . ($key + 1) .'" class="box-alternativa box-shadow px-4 py-4 rounded-10 my-3 ' . ($aula->conteudo->completo ? ($resposta == ($key + 1) ? ($aula->conteudo->correto ? 'alternativa-correta' : 'alternativa-incorreta') : 'alternativa-desativada') : '') . '">
                            <div class="custom-control custom-radio h4">
                                <input type="radio" id="alternativa' . ($key + 1) .'" name="alternativas" onchange="selecionarAlternativa(this.id);" class="custom-control-input" ' . ($aula->conteudo->completo ? ($resposta == ($key + 1) ? 'checked' : '' ) : '') . '>
                                <label class="custom-control-label pl-4 d-block" for="alternativa' . ($key + 1) .'">' . $alternativa . '</label>
                            </div>
                        </div>';
                    }

                    $aula->conteudo->conteudo .= '
                        <div id="divRespostaCorreta" class="p-3 ' . ($aula->conteudo->completo ? ($aula->conteudo->correto ? '' : 'd-none') : 'd-none') . '">
                            <h4 style="color: #008CC8;">
                                <i class="fas fa-check fa-fw mr-2 fa-lg"></i>
                                Parabéns, você acertou!
                            </h4>
                        </div>
                        <div id="divRespostaIncorreta" class="p-3 ' . ($aula->conteudo->completo ? ($aula->conteudo->correto ? 'd-none' : '') : 'd-none') . '">
                            <h4 style="color: #ee9164;">
                                <i class="fas fa-times fa-fw mr-2 fa-lg"></i>
                                Que pena, você não acertou! Tente novamente.
                            </h4>
                        </div>
                        <div class="text-right">
                            <button id="btnConfirmarResposta" type="button" onclick="confirmarResposta();" class="btn bg-bluelight btn-lg py-2 px-4 rounded-10 text-uppercase font-weight-bold text-truncate col-12 col-sm-auto ' . ($aula->conteudo->completo ? 'd-none' : '') . '" style="color: #525870; border: 3px solid #008cc8;">
                                Confirmar
                            </button>
                            <button id="btnTentarNovamente" type="button" onclick="tentarNovamente();" class="btn bg-bluelight btn-lg py-2 px-4 rounded-10 text-uppercase font-weight-bold text-truncate col-12 col-sm-auto ' . ($aula->conteudo->completo == false ? 'd-none' : '') . ($aula->conteudo->correto == true ? 'd-none' : '') . '" style="color: #525870; border: 3px solid #008cc8;">
                                Tentar novamente
                            </button>
                        </div>
                    </div>';
                }
                else if($aula->conteudo->tipo == 9)
                {
                    $perguntas = json_decode($aula->conteudo->conteudo);

                    $cmbPerguntas = '';

                    $tempConteudoCompleto = null;

                    if($aula->conteudo->completo)
                    {
                        $tempConteudoCompleto = ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first();
                        $tempConteudoCompleto->resposta = json_decode($tempConteudoCompleto->resposta);
                        if($tempConteudoCompleto->correta !== null)
                        {
                            $tempConteudoCompleto->correta = json_decode($tempConteudoCompleto->correta);
                        }
                    }

                    for ($i=0; $i < count($perguntas); $i++)
                    {
                        $cmbPerguntas = $cmbPerguntas . '<option value="' . ($i + 1) . '" ' . ($i == 0 ? 'selected' : '') . '>Questão ' . ($i + 1) . '</option>';
                    }

                    $aula->conteudo->conteudo = '<div class="px-3 py-2">
                    <div class="form-group mb-3">
                        <select class="custom-select form-control d-inline-block mr-2" id="cmbQuestaoAtual" onchange="mudouPerguntaProvaAtual();" style="width: auto; min-width: 200px;">
                            ' . $cmbPerguntas . '
                        </select>
                    </div>';

                    $divPerguntas = '';

                    $totalCorretas = 0;
                    $totalPontos = 0;

                    foreach ($perguntas as $key => $pergunta)
                    {
                        $divPerguntas = $divPerguntas . '<div id="divPergunta' . ($key + 1) . '" data-tipo="' . $pergunta->tipo . '" class="' . ($key > 0 ? 'd-none' : '') . '">';

                        $divPerguntas = $divPerguntas . '<h2>' . ucfirst($pergunta->pergunta) . ' <small class="text-muted mr-3">(Peso: ' . $pergunta->peso . ')</small> ' . ($key + 1) . '/' . count($perguntas) . '</h2>';

                        $pergunta->correta = null;
                        if($tempConteudoCompleto != null)
                        {
                            if($tempConteudoCompleto->correta !== null)
                            {
                                if($tempConteudoCompleto->correta[$key] == "1")
                                {
                                    $pergunta->correta = true;
                                    $totalCorretas ++;
                                    $totalPontos += $pergunta->peso;
                                }
                                else
                                {
                                    $pergunta->correta = false;
                                }
                            }
                        }

                        if($pergunta->tipo == 1)
                        {
                            $divPerguntas = $divPerguntas . '
                            <div id="boxResposta" class="box-alternativa box-shadow px-4 py-4 rounded-10 my-3 ' . ($aula->conteudo->completo ? ($pergunta->correta !== null ? ($pergunta->correta === true ? 'alternativa-correta' : 'alternativa-incorreta') : '') : '') . '">
                                <div class="form-group mb-3 text-left">
                                    <textarea class="form-control" name="resposta" id="txtRespostaDissertativa" rows="3" placeholder="Clique para digitar sua resposta." ' . ($aula->conteudo->completo ? 'readonly' : '') . '>' . ($aula->conteudo->completo ? $tempConteudoCompleto->resposta[$key] : '') . '</textarea>
                                </div>
                            </div>';
                        }
                        else
                        {
                            foreach ($pergunta->alternativas as $key2 => $alternativa)
                            {
                                $divPerguntas = $divPerguntas . '
                                <div id="boxAlternativa' . ($key2 + 1) .'" class="box-alternativa box-shadow px-4 py-4 rounded-10 my-3 ' . ($aula->conteudo->completo ? 'alternativa-desativada' : '') . ' ' . ($aula->conteudo->completo ? (($key2 + 1) == $tempConteudoCompleto->resposta[$key] ? ($pergunta->correta !== null ? ($pergunta->correta === true ? 'alternativa-correta' : 'alternativa-incorreta') : '') : '') : '') . '">
                                    <div class="custom-control custom-radio h4">
                                        <input type="radio" id="alternativa' . ($key + 1) .'-' . ($key2 + 1) .'" class="custom-control-input" ' . ($aula->conteudo->completo ? 'readonly' : '') . ' ' . ($aula->conteudo->completo ? (($key2 + 1) == $tempConteudoCompleto->resposta[$key] ? 'checked' : '') : '') . '>
                                        <label class="custom-control-label pl-4 d-block" for="alternativa' . ($key + 1) .'-' . ($key2 + 1) .'">' . $alternativa .  '</label>
                                    </div>
                                </div>';
                            }
                        }

                        $divPerguntas = $divPerguntas . '</div>';
                    }

                    $aula->conteudo->conteudo = $aula->conteudo->conteudo . '<div id="divPerguntas">
                        ' . $divPerguntas . '
                    </div>';

                    $aula->conteudo->conteudo .= '
                        <div id="divAguardandoCorrecao" class="p-3 ' . ($aula->conteudo->completo ? $tempConteudoCompleto->correta !== null ? 'd-none' : '' : 'd-none') . '">
                            <h4>
                                <i class="fas fa-clock fa-fw mr-2 fa-lg"></i>
                                Aguardando correção do professor.
                            </h4>
                        </div>
                        <div id="divRespostaCorreta" class="p-3 ' . ($aula->conteudo->completo ? $tempConteudoCompleto->correta !== null ? '' : 'd-none' : 'd-none') . '">
                            <h4 style="color: #008CC8;">
                                <i class="fas fa-check fa-fw mr-2 fa-lg"></i>
                                Você concluiu! Sua pontuação total foi de: ' . $totalPontos . ' e acertou ' . $totalCorretas . ' de ' . count($perguntas) . '.
                            </h4>
                        </div>
                        <div id="divRespostaIncorreta" class="p-3 d-none">
                            <h4 style="color: #ee9164;">
                                <i class="fas fa-times fa-fw mr-2 fa-lg"></i>
                                Que pena, você não acertou! Tente novamente.
                            </h4>
                        </div>
                        <div class="text-right">
                            <button id="btnConfirmarResposta" type="button" onclick="confirmarRespostaProva();" class="btn bg-bluelight btn-lg py-2 px-4 rounded-10 text-uppercase font-weight-bold text-truncate col-12 col-sm-auto ' . ($aula->conteudo->completo ? 'd-none' : '') . '" style="color: #525870; border: 3px solid #008cc8;">
                                Confirmar e prosseguir
                            </button>
                            <button id="btnTentarNovamente" type="button" onclick="tentarNovamenteProva();" class="btn bg-bluelight btn-lg py-2 px-4 rounded-10 text-uppercase font-weight-bold text-truncate col-12 col-sm-auto ' . ($aula->conteudo->completo && $aula->conteudo->correto === true ? '' : 'd-none') . '" style="color: #525870; border: 3px solid #008cc8;">
                                Recomeçar a prova
                            </button>
                        </div>
                    </div>';

                }
                else if($aula->conteudo->tipo == 10)
                {
                    if($aula->conteudo->completo)
                    {
                        if(ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first()->correta === "1")
                            $aula->conteudo->correto = true;
                        elseif(ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first()->correta === "0")
                            $aula->conteudo->correto = false;
                        else
                            $aula->conteudo->correto = null;
                    }
                    else
                    {
                        $aula->conteudo->correto = null;
                    }

                    $aula->conteudo->conteudo = '<div class="px-3 py-2">
                        <h2>' . ($aula->conteudo->conteudo) . '</h2>';

                    if($aula->conteudo->completo != null)
                    {
                        $idResposta = ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first()->id;

                        if($aula->conteudo->correto != null)
                        {
                            $aula->conteudo->conteudo = $aula->conteudo->conteudo . '
                            <div id="boxResposta" class="box-alternativa box-shadow px-4 py-4 rounded-10 my-3 w-auto d-inline-block ' . ($aula->conteudo->correto ? 'alternativa-correta' : 'alternativa-incorreta') . '" style="pointer-events: initial;">
                                <a href="' . route('gestao.entregaveis-arquivo', ['idResposta' => $idResposta]) . '" target="_blank" class="btn bg-bluelight px-5 signin-button m-0 text-dark font-weight-bold">
                                    <i class="fas fa-paperclip fa-lg text-primary mr-2 align-middle"></i>
                                    Baixar arquivo
                                </a>
                            </div>';
                        }
                        else
                        {
                            $aula->conteudo->conteudo = $aula->conteudo->conteudo . '
                            <div id="boxResposta" class="box-alternativa box-shadow px-4 py-4 rounded-10 my-3 w-auto d-inline-block" style="pointer-events: initial;">
                                <a href="' . route('gestao.entregaveis-arquivo', ['idResposta' => $idResposta]) . '" target="_blank" class="btn bg-bluelight px-5 signin-button m-0 text-dark font-weight-bold">
                                    <i class="fas fa-paperclip fa-lg text-primary mr-2 align-middle"></i>
                                    Baixar arquivo
                                </a>
                            </div>';
                        }
                    }
                    else
                    {
                        $aula->conteudo->conteudo = $aula->conteudo->conteudo . '<form id="formEnviarEntregavel" method="POST" action="' . route('curso.play.enviar-entregavel', ['idCurso' => $idCurso, 'idAula' => $idAula, 'idConteudo' => $aula->conteudo->id]) . '" enctype="multipart/form-data" class="">
                            ' . csrf_field() .  '

                            <div id="divEnviando" class="text-center d-none">
                                <i class="fas fa-spinner fa-pulse fa-3x text-primary mb-3"></i>
                                <h4>Enviando</h4>
                            </div>

                            <div id="divEditar" class="form-page">

                                <div class="row">
                                    <div class="col my-auto">
                                        <label for="arquivo" class="btn btn-outline px-3 py-2 text-uppercase font-weight-bold position-relative m-0" style="border-width: 1px;border: 2px solid #008CC8;color: #008CC8;">
                                            <input type="file" class="custom-file-input" id="arquivo" name="arquivo" style="top: 0px;height:  100%;position:  absolute;left:  0px;" oninput="anexouArquivo(this);">
                                            <i class="fas fa-paperclip fa-lg text-primary mr-2 align-middle"></i>
                                            <span id="lblNomeArquivo">Clique para enviar seu arquivo</span>
                                        </label>
                                    </div>

                                    <div class="col my-auto text-right">
                                        <button id="btnEnviarEntregavel" type="submit" onclick="enviarEntregavel();" class="btn bg-bluelight px-5 signin-button m-0 text-dark font-weight-bold">Enviar</button>
                                    </div>
                                </div>

                            </div>

                        </form>';
                    }

                    if($aula->conteudo->correto === null)
                    {
                        $aula->conteudo->conteudo .= '
                        <div id="divAguardandoCorrecao" class="p-3 ' . ($aula->conteudo->completo ? '' : 'd-none') . '">
                            <h4>
                                <i class="fas fa-clock fa-fw mr-2 fa-lg"></i>
                                Aguardando correção do professor.
                            </h4>
                        </div>';
                    }
                    else
                    {
                        $aula->conteudo->conteudo .= '
                        <div id="divAguardandoCorrecao" class="p-3 d-none">
                            <h4>
                                <i class="fas fa-clock fa-fw mr-2 fa-lg"></i>
                                Aguardando correção do professora.
                            </h4>
                        </div>
                        <div id="divRespostaCorreta" class="p-3 ' . ($aula->conteudo->correto ? '' : 'd-none') . '">
                            <h4 style="color: #008CC8;">
                                <i class="fas fa-check fa-fw mr-2 fa-lg"></i>
                                Parabéns, você acertou!
                            </h4>
                        </div>
                        <div id="divRespostaIncorreta" class="p-3 ' . ($aula->conteudo->correto ? 'd-none' : '') . '">
                            <h4 style="color: #ee9164;">
                                <i class="fas fa-times fa-fw mr-2 fa-lg"></i>
                                Que pena, você não acertou! Tente novamente.
                            </h4>
                        </div>';

                        if(!$aula->conteudo->correto)
                        {
                            $aula->conteudo->conteudo .= '
                                <div class="text-right">
                                    <button id="btnTentarNovamente" type="button" onclick="tentarNovamente();" class="btn bg-bluelight btn-lg py-2 px-4 rounded-10 text-uppercase font-weight-bold text-truncate col-12 col-sm-auto ' . ($aula->conteudo->completo == false ? 'd-none' : '') . ($aula->conteudo->correto == true ? 'd-none' : '') . '" style="color: #525870; border: 3px solid #008cc8;">
                                        Enviar novo arquivo
                                    </button>
                                </div>
                            </div>';

                            $aula->conteudo->conteudo = $aula->conteudo->conteudo . '<form id="formEnviarEntregavel" method="POST" action="' . route('curso.play.enviar-entregavel', ['idCurso' => $idCurso, 'idAula' => $idAula, 'idConteudo' => $aula->conteudo->id]) . '" enctype="multipart/form-data" class="d-none">
                                ' . csrf_field() .  '

                                <div id="divEnviando" class="text-center d-none">
                                    <i class="fas fa-spinner fa-pulse fa-3x text-primary mb-3"></i>
                                    <h4>Enviando</h4>
                                </div>

                                <div id="divEditar" class="form-page">

                                    <div class="row">
                                        <div class="col my-auto">
                                            <label for="arquivo" class="btn btn-outline px-3 py-2 text-uppercase font-weight-bold position-relative m-0" style="border-width: 1px;border: 2px solid #008CC8;color: #008CC8;">
                                                <input type="file" class="custom-file-input" id="arquivo" name="arquivo" style="top: 0px;height:  100%;position:  absolute;left:  0px;" oninput="anexouArquivo(this);">
                                                <i class="fas fa-paperclip fa-lg text-primary mr-2 align-middle"></i>
                                                <span id="lblNomeArquivo">Clique para enviar seu arquivo</span>
                                            </label>
                                        </div>

                                        <div class="col my-auto text-right">
                                            <button id="btnEnviarEntregavel" type="submit" onclick="enviarEntregavel();" class="btn bg-bluelight px-5 signin-button m-0 text-dark font-weight-bold">Enviar</button>
                                        </div>
                                    </div>

                                </div>

                            </form>';
                        }

                    }
                }
                else if ($aula->conteudo->tipo == 11)
                {
                    $url_apostila = env("APP_LOCAL") . '/uploads/apostilas/' . $aula->conteudo->id;

                    $aula->conteudo->conteudo = '<iframe src="' . env("APP_LOCAL") . '/leitor_apostila/' . $aula->conteudo->id . '?conteudo_id=' . $aula->conteudo->id . '&url=' . $url_apostila . '" style="width: 100%; height: 41vw;" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen>
                        </iframe>';
                }

                $aula->conteudo->comentarios = ComentarioConteudo::with('user')->where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso]])->orderBy('created_at', 'desc')->get();

                $aula->conteudo->qtAvaliacoesPositivas = AvaliacaoConteudo::where([['avaliacao', '=', '1']])->count();

                $aula->conteudo->qtAvaliacoesNegativas = AvaliacaoConteudo::where([['avaliacao', '=', '0']])->count();

                $aula->conteudo->minhaAvaliacao = AvaliacaoConteudo::where([['user_id', '=', Auth::user()->id]])->first();

                if($aula->conteudo->apoio != null)
                {
                    $aula->conteudo->apoio = \HelperClass::linkfy($aula->conteudo->apoio);
                    $aula->conteudo->apoio = strip_tags($aula->conteudo->apoio, '<a>');
                }

                if($aula->conteudo->fonte != null)
                {
                    $aula->conteudo->fonte = \HelperClass::linkfy($aula->conteudo->fonte);
                    $aula->conteudo->fonte = strip_tags($aula->conteudo->fonte, '<a>');
                }

                if($aula->conteudo->autores != null)
                {
                    $aula->conteudo->autores = \HelperClass::linkfy($aula->conteudo->autores);
                    $aula->conteudo->autores = strip_tags($aula->conteudo->autores, '<a>');
                }

                if(\Session::has('aulaCompleta') ? (\Session::get('aulaCompleta') == true) : false)
                {
                    return response()->json(['success'=> 'Aula e conteudo encontrada.', 'aula' => json_encode($aula), 'aulaCompleta' => true]);
                }
                else
                {
                    return response()->json(['success'=> 'Aula e conteudo encontrada.', 'aula' => json_encode($aula)]);
                }

            }
            else
            {
                return response()->json(['error' => 'Conteudo não encontrado']);
            }
        }
        else
        {
            // dd(\Session::get('aulaCompleta'));

            return response()->json(['error' => 'Aula não encontrada']);
        }
    }

    function playGetProximoConteudo($idCurso, $idAula, $idConteudo)
    {
        $this->checkMatricula($idCurso);

        if($idAula == 0)
        {
            $idAula = Aula::where([['curso_id', '=', $idCurso]])->first()->id;
        }

        if($idConteudo == 0)
        {
            // $idConteudo = Conteudo::where([['aula_id', '=', $idAula], ['curso_id', '=', $idCurso]])->first()->id;
            $idConteudo = Conteudo::whereHas('conteudos_aula', function ($query) use ($idAula, $idCurso) {
                $query->where([['aula_id', '=', $idAula], ['curso_id', '=', $idCurso]]);
            })->first()->id;

            // dd($idConteudo);
        }

        $proximaAula = $idAula;

        $curso_atual = Curso::find($idCurso);

        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            $aula_atual = Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first();

            if(Conteudo::where([['id', '=', $idConteudo]])->first() != null)
            {
                $tipoConteudo = Conteudo::where([['id', '=', $idConteudo]])->first()->tipo;

                if($tipoConteudo != 7 && $tipoConteudo != 8 && $tipoConteudo != 9 && $tipoConteudo != 10)
                {
                    if(ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first() == null)
                    {
                        ConteudoCompleto::create([
                            'curso_id' => $idCurso,
                            'aula_id' => $idAula,
                            'conteudo_id' => $idConteudo,
                            'user_id' => Auth::user()->id
                        ]);

                        $qt_conteudos_aula_atual = ConteudoAula::where([['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['obrigatorio', '=', 1]])->count();

                        $qt_conteudos_aula_atual_completos = ConteudoCompleto::where([['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->count();

                        $aula_completa = ($qt_conteudos_aula_atual_completos >= $qt_conteudos_aula_atual);

                        if($aula_completa)
                        {
                            Notificacao::create([
                                'user_id' => Auth::user()->id,
                                'titulo' => "Aula concluída",
                                'descricao' => "Parabéns, você concluiu a aula " . ( $aula_atual->titulo ),
                                'tipo' => 2,
                            ]);

                            \App\Services\GamificacaoService::aulaConcluidaIncrement();
                        }

                        $qt_conteudos_curso_atual = ConteudoAula::where([['curso_id', '=', $idCurso], ['obrigatorio', '=', 1]])->count();

                        $qt_conteudos_curso_atual_completos = ConteudoCompleto::where([['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->count();

                        $curso_completo = ($qt_conteudos_curso_atual_completos >= $qt_conteudos_curso_atual);

                        if($curso_completo)
                        {
                            if($curso_atual != null)
                            {
                                Notificacao::create([
                                    'user_id' => Auth::user()->id,
                                    'titulo' => "Curso concluído!",
                                    'descricao' => "Parabéns, você concluiu o curso " . ( $curso_atual->titulo ),
                                    'tipo' => 2,
                                ]);
                            }

                            \App\Services\GamificacaoService::cursoConcluidoIncrement();
                        }

                        if(BadgeUsuario::where([['badge_id', '=', 12], ['user_id', '=', Auth::user()->id]])->exists() == false)
                        {
                            BadgeUsuario::create([
                                'badge_id' => 12,
                                'user_id' => Auth::user()->id,
                            ]);
                        }
                    }
                }
            }
        }

        $conteudoAtual = Conteudo::with('conteudo_aula')
        ->whereHas('conteudo_aula', function ($query) use ($idCurso, $idAula) {
            $query->where([['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]]);
        })
        ->where([['id', '=', $idConteudo]])
        ->first();

        // dd($conteudoAtual);

        if($conteudoAtual == null)
        {
            return response()->json(['error' => 'Conteúdo atual não encontrado!', "aulaAtual" => $idAula, "conteudoAtual" => $idConteudo]);
        }

        $proximoConteudo = Conteudo::with('conteudos_aula')->whereHas('conteudos_aula', function ($query) use ($idCurso, $idAula, $conteudoAtual) {
            $query->where([['curso_id', '=', $idCurso], ['aula_id', '=', $idAula], ['ordem', '>', $conteudoAtual->conteudo_aula->ordem]]);
        // })->orderBy('ordem', 'asc')->pluck('id')->first();
        })
        ->get()
        ->sortBy('conteudos_aula.ordem')
        ->pluck('id')
        ->first();

        // dd($proximoConteudo);

        // if(Conteudo::where([['ordem', '>', $conteudoAtual->ordem]])->whereDoesntHave('conteudo_completo')->orderBy('ordem', 'asc')->pluck('id')->first() != null)
        // {
            // $proximoConteudo = Conteudo::where([['ordem', '>', $conteudoAtual->ordem]])->orderBy('ordem', 'asc')->pluck('id')->first();
        // }
        // else
        if($proximoConteudo == null)
        {
            $aulaCompleta = true;

            // dd(Conteudo::with('conteudo_aula')
            // ->whereHas('conteudo_aula', function ($query) use ($idCurso, $idAula) {
            //     $query->where([['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]]);
            // })->get()->sortBy('conteudos_aula.ordem'));

            // foreach (Conteudo::where([['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['obrigatorio', '=', 1]])->orderBy('ordem')->get() as $key => $value)
            foreach (Conteudo::with('conteudo_aula')
            ->whereHas('conteudo_aula', function ($query) use ($idCurso, $idAula) {
                $query->where([['curso_id', '=', $idCurso], ['aula_id', '=', $idAula]]);
            })->get()->sortBy('conteudos_aula.ordem') as $key => $value)
            {
                if(ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['conteudo_id', '=', $value->id], ['aula_id', '=', $value->conteudo_aula->aula_id], ['curso_id', '=', $value->conteudo_aula->curso_id]])->first() == null)
                {
                    $proximaAula = $value->aula_id;
                    $proximoConteudo = $value->id;

                    $aulaCompleta = false;

                    break;
                }
                else
                {
                    continue;
                }
            }

            if($aulaCompleta == true)
            {
                if(Aula::where([['id', '>', $idAula], ['curso_id', '=', $idCurso]])->orderBy('id')->pluck('id')->first() != null)
                {
                    $proximaAula = Aula::where([['id', '>', $idAula], ['curso_id', '=', $idCurso]])->orderBy('id')->pluck('id')->first();

                    // dd($proximaAula);

                    $proximoConteudo = Conteudo::with('conteudos_aula')->whereHas('conteudos_aula', function ($query) use ($proximaAula, $idCurso) {
                        $query->where([['aula_id', '=', $proximaAula], ['curso_id', '=', $idCurso]]);
                    // })->orderBy('ordem', 'asc')->pluck('id')->first();
                    })
                    ->get()
                    ->sortBy('conteudos_aula.ordem')
                    ->pluck('id')
                    ->first();

                    // if(Conteudo::where([['aula_id', '=', $proximaAula], ['curso_id', '=', $idCurso]])->orderBy('ordem', 'asc')->pluck('id')->first() != null)
                    // {
                    //     $proximoConteudo = Conteudo::where([['aula_id', '=', $proximaAula], ['curso_id', '=', $idCurso]])->orderBy('ordem', 'asc')->pluck('id')->first();
                    // }
                    // else
                    if($proximoConteudo == null)
                    {
                        if(CursoCompleto::where([['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first() == null)
                        {
                            CursoCompleto::create([
                                'user_id' => Auth::user()->id,
                                'curso_id' => $idCurso
                            ]);
                        }

                        return response()->json(['error' => 'Não há próximo conteúdo', 'cursoCompleto' => true]);
                    }
                }
                else
                {
                    if(CursoCompleto::where([['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first() == null)
                    {
                        CursoCompleto::create([
                            'user_id' => Auth::user()->id,
                            'curso_id' => $idCurso
                        ]);
                    }

                    return response()->json(['error' => 'Não há próxima aula', 'cursoCompleto' => true]);

                }
            }

            \Session::flash('aulaCompleta', $aulaCompleta);
        }


        return $this->playGetConteudo($idCurso, $proximaAula, $proximoConteudo);
    }

    public function postEnviarResposta($idCurso, $idAula, $idConteudo, Request $request)
    {
        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            if(Conteudo::where([['id', '=', $idConteudo]])->first() != null)
            {
                if(ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['user_id', '=', Auth::user()->id]])->first() == null)
                {
                    $tempCont = json_decode(Conteudo::where([['id', '=', $idConteudo]])->first()->conteudo);

                    if(Conteudo::where([['id', '=', $idConteudo]])->first()->tipo == 7 || Conteudo::where([['id', '=', $idConteudo]])->first()->tipo == 9)
                    {
                        $resposta = $request->resposta;
                    }
                    else
                    {
                        $resposta = $request->alternativa;
                    }

                    $conteudoCompleto = ConteudoCompleto::create([
                        'curso_id' => $idCurso,
                        'aula_id' => $idAula,
                        'conteudo_id' => $idConteudo,
                        'user_id' => Auth::user()->id,
                        'resposta' => $resposta,
                    ]);

                    if(Conteudo::where([['id', '=', $idConteudo]])->first()->tipo == 7 || Conteudo::where([['id', '=', $idConteudo]])->first()->tipo == 9)
                    {
                        if(Conteudo::where([['id', '=', $idConteudo]])->first()->tipo == 9)
                        {
                            $provaQuiz = true;

                            foreach ($tempCont as $pergunta)
                            {
                                if($pergunta->tipo == 1)
                                {
                                    $provaQuiz = false;
                                }
                            }

                            if($provaQuiz)
                            {
                                $correta = [];

                                $resposta = json_decode($resposta);

                                foreach ($tempCont as $key => $pergunta)
                                {
                                    if($pergunta->correta == $resposta[$key])
                                    {
                                        array_push($correta, 1);
                                    }
                                    else
                                    {
                                        array_push($correta, 0);
                                    }
                                }

                                $conteudoCompleto->update(['correta' => json_encode($correta)]);
                            }
                        }

                        return response()->json(['success' => 'Aguardando correção!']);
                    }
                    else
                    {
                        if($request->alternativa == $tempCont->correta)
                        {
                            return response()->json(['success' => 'Resposta correta!', 'correta' => true]);
                        }
                        else
                        {
                            return response()->json(['success' => 'Resposta incorreta!', 'correta' => false]);
                        }
                    }
                }
                else
                {
                    $tempCont = json_decode(Conteudo::where([['id', '=', $idConteudo]])->first()->conteudo);

                    if(Conteudo::where([['id', '=', $idConteudo]])->first()->tipo == 7 || Conteudo::where([['id', '=', $idConteudo]])->first()->tipo == 9)
                    {
                        $resposta = $request->resposta;
                    }
                    else
                    {
                        $resposta = $request->alternativa;
                    }

                    ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['user_id', '=', Auth::user()->id]])->first()->update([
                        'resposta' => $resposta
                    ]);

                    if(Conteudo::where([['id', '=', $idConteudo]])->first()->tipo == 7)
                    {
                        ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['user_id', '=', Auth::user()->id]])->first()->update([
                            'correta' => null
                        ]);

                        return response()->json(['success' => 'Aguardando correção!']);
                    }
                    else
                    {
                        if($request->alternativa == $tempCont->correta)
                        {
                            return response()->json(['success' => 'Resposta correta!', 'correta' => true]);
                        }
                        else
                        {
                            return response()->json(['success' => 'Resposta incorreta!', 'correta' => false]);
                        }
                    }

                    // return response()->json(['success' => 'Conteúdo já respondido!', 'correta' => ($resposta == $tempCont->correta)]);
                }
            }
            else
            {
                return response()->json(['error' => 'Conteúdo não encontrado!']);
            }
        }
        else
        {
            return response()->json(['error' => 'Aula não encontrada!']);
        }
    }

    public function postEnviarEntregavel($idCurso, $idAula, $idConteudo, Request $request)
    {
        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            if(Conteudo::where([['id', '=', $idConteudo]])->first() != null)
            {
                if(ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first() == null)
                {
                    $conteudoCompleto = ConteudoCompleto::create([
                        'curso_id' => $idCurso,
                        'aula_id' => $idAula,
                        'conteudo_id' => $idConteudo,
                        'user_id' => Auth::user()->id
                    ]);
                }
                else
                {
                    $conteudoCompleto = ConteudoCompleto::where([['conteudo_id', '=', $idConteudo], ['aula_id', '=', $idAula], ['curso_id', '=', $idCurso], ['user_id', '=', Auth::user()->id]])->first();

                    $conteudoCompleto->update([
                        'correta' => null
                    ]);
                }

                if($conteudoCompleto->resposta != "")
                {
                    if(\Storage::disk('local')->has('uploads/entregavel/aluno/' . Auth::user()->id .'/' . $conteudoCompleto->resposta))
                    {
                        \Storage::disk('local')->delete('uploads/entregavel/aluno/' . Auth::user()->id .'/' . $conteudoCompleto->resposta);
                    }
                }

                if($request->arquivo != null)
                {
                    $originalName = mb_strtolower( $request->arquivo->getClientOriginalName(), 'utf-8' );

                    $fileExtension = \File::extension($request->arquivo->getClientOriginalName());
                    $newFileNameArquivo =  md5( $request->arquivo->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

                    $pathArquivo = $request->arquivo->storeAs('uploads/entregavel/aluno/' . Auth::user()->id .'/', $newFileNameArquivo, 'local');

                    if(!\Storage::disk('local')->put($pathArquivo, file_get_contents($request->arquivo)))
                    {
                        \Session::flash('error', 'Não foi possível fazer upload de seu anexo!');
                    }
                    else
                    {
                        $conteudoCompleto->update([
                            'resposta' => $newFileNameArquivo
                        ]);
                    }
                }
            }
        }

        return Redirect::back()->with('message', 'Entragável enviado com sucesso!');
    }

    function playGetArquivo($idCurso, $idAula, $idConteudo)
    {
        if(Curso::find($idCurso))
        {
            $curso = Curso::with('aulas')->find($idCurso);
        }
        else
        {
            return response()->json(['error' => 'Curso não encontrado']);
        }

        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            if(Conteudo::where([['id', '=', $idConteudo]])->first() != null)
            {
                $conteudo = Conteudo::where([['id', '=', $idConteudo]])->first();

                if(strpos($conteudo->conteudo, ".ppt") === false && strpos($conteudo->conteudo, ".html") === false)
                {
                    if(!Auth::check())
                    {
                        return response()->json(['error' => 'Usuário não autenticado!']);
                    }

                    $tem_matricula = Matricula::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $curso->id]])->exists();

                    $is_admin = (Auth::user()->permissao == "Z");

                    $is_content_owner = (Auth::user()->id == $conteudo->user_id);

                    if( !$tem_matricula && !$is_admin && !$is_content_owner )
                    {
                        return response()->json(['error' => 'Matricula não encontrada']);
                    }
                }

                if(\Storage::disk('local')->has('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo)
                // || \Storage::disk('gcs')->has('uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo)
                )
                {
                    $filePath = 'uploads/cursos/' . $idCurso . '/arquivos/' . $conteudo->conteudo;

                    // if(\Storage::disk('gcs')->exists($filePath))
                    // {
                    //     // dd(Storage::disk('gcs')->temporaryUrl( $filePath, now()->addSeconds(30) ));

                    //     // dd("Testing.");

                    //     // dd(\Storage::disk('gcs')->size($filePath) / 1000000); //Size in bytes / 1+e6 = size in mb

                    //     // dd(Carbon::createFromTimestamp(\Storage::disk('gcs')->lastModified($filePath))->toDateTimeString());

                    //     if(\Storage::disk('gcs')->getVisibility($filePath) == 'public')
                    //     {
                    //         \Storage::disk('gcs')->setVisibility($filePath, 'private');
                    //         // \Storage::disk('gcs')->setVisibility($filePath, 'public');
                    //     }

                    //     // Return temporary signed url
                    //     // \Storage::disk('gcs')->getAdapter()->getBucket()->object($filePath)->signedUrl(now()->addSeconds(120));

                    //     return \Storage::disk('gcs')->response($filePath);
                    // }
                    // else
                    {
                        // Single byte streaming file response
                        return \Storage::disk('local')->response($filePath);
                    }

                    // MultiByte streaming file response
                    // return $this->streamFile(Storage::mimeType($filePath), storage_path('app/'. $filePath));
                }
                else
                {
                    return $conteudo->conteudo;
                }
            }
            else
            {
                return response()->view('errors.404');
            }
        }
        else
        {
            return response()->view('errors.404');
        }
    }

    // Provide a streaming file with support for scrubbing
    private function streamFile( $contentType, $path )
    {
		$fullsize = filesize($path);
		$size = $fullsize;
		$stream = fopen($path, "r");
		$response_code = 200;
		$headers = array("Content-type" => $contentType);

		// Check for request for part of the stream
		$range = \Request::header('Range');
		if($range != null) {
			$eqPos = strpos($range, "=");
			$toPos = strpos($range, "-");
			$unit = substr($range, 0, $eqPos);
			$start = intval(substr($range, $eqPos+1, $toPos));
			$success = fseek($stream, $start);
			if($success == 0) {
				$size = $fullsize - $start;
				$response_code = 206;
				$headers["Accept-Ranges"] = $unit;
				$headers["Content-Range"] = $unit . " " . $start . "-" . ($fullsize-1) . "/" . $fullsize;
			}
		}

		$headers["Content-Length"] = $size;

		return \Response::stream(function () use ($stream) {
			fpassthru($stream);
		}, $response_code, $headers);
	}

    public function postEnviarAvaliacaoCurso($idCurso, Request $request)
    {
        if(Curso::find($idCurso) == null)
        {
            return response()->json(['error' => 'Curso não encontrado!']);
        }

        // $qtConteudos = Conteudo::where([['curso_id', '=', $idCurso], ['obrigatorio', '=', 1]])->count();

        $qtConteudos = Conteudo::with('conteudos_aula')->whereHas('conteudos_aula', function ($query) use ($idCurso) {
            $query->where([['curso_id', '=', $idCurso], ['obrigatorio', '=', 1]]);
        })->count();

        if(ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $idCurso]])->count() < $qtConteudos)
        {
            return response()->json(['error' => 'Curso incompleto!']);
        }

        if($request->comentario == null)
        {
            $request->comentario = '';
        }

        AvaliacaoCurso::updateOrCreate(
            [
                'user_id' => Auth::user()->id,
                'curso_id' => $idCurso
            ],
            ['avaliacao' => $request->avaliacao, 'descricao' => $request->comentario]
        );

        return response()->json(['success' => 'Avaliação enviada com sucesso!']);

    }

    public function postEnviarAvaliacaoEscola($escola_id, Request $request)
    {
        if(Escola::find($escola_id) == null)
        {
            return response()->json(['error' => 'Escola não encontrada!']);
        }

        // $qtConteudos = Conteudo::where([['curso_id', '=', $idCurso], ['obrigatorio', '=', 1]])->count();

        // $qtConteudos = Conteudo::with('conteudos_aula')->whereHas('conteudos_aula', function ($query) use ($idCurso) {
        //     $query->where([['curso_id', '=', $idCurso], ['obrigatorio', '=', 1]]);
        // })->count();

        // if(ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $idCurso]])->count() < $qtConteudos)
        // {
        //     return response()->json(['error' => 'Curso incompleto!']);
        // }

        if($request->comentario == null)
        {
            $request->comentario = '';
        }

        AvaliacaoEscola::updateOrCreate(
            [
                'user_id' => Auth::user()->id,
                'escola_id' => $escola_id
            ],
            ['avaliacao' => $request->avaliacao, 'descricao' => $request->comentario]
        );

        return response()->json(['success' => 'Avaliação enviada com sucesso!']);

    }

    public function postEnviarAvaliacaoProfessor($idCurso, Request $request)
    {
        if(Curso::find($idCurso) == null)
        {
            return response()->json(['error' => 'Curso não encontrado!']);
        }

        $idInstrutor = Curso::find($idCurso)->user_id;

        if(ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $idCurso]])->count() < Conteudo::where([['curso_id', '=', $idCurso], ['obrigatorio', '=', 1]])->count())
        {
            return response()->json(['error' => 'Curso incompleto!']);
        }

        if($request->comentario == null)
        {
            $request->comentario = '';
        }

        AvaliacaoInstrutor::updateOrCreate(
            [
                'user_id' => Auth::user()->id,
                'instrutor_id' => $idInstrutor
            ],
            ['avaliacao' => $request->avaliacao, 'descricao' => $request->comentario]
        );

        return response()->json(['success' => 'Avaliação enviada com sucesso!']);

    }

    public function postEnviarAvaliacaoConteudo($idCurso, $idAula, $idConteudo, Request $request)
    {
        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            if(Conteudo::where([['id', '=', $idConteudo]])->first() != null)
            {
                // if(AvaliacaoConteudo::updateOrCreate(
                //     [
                //         'user_id' => Auth::user()->id,
                //         'curso_id' => $idCurso,
                //         'aula_id' => $idAula,
                //         'conteudo_id' => $idConteudo,
                //     ],
                //     ['avaliacao' => $request->avaliacao]
                // )->exists())
                // {
                //     AvaliacaoConteudo::updateOrCreate(['user_id' => Auth::user()->id, 'curso_id' => $idCurso, 'aula_id' => $idAula, 'conteudo_id' => $idConteudo],
                //         ['avaliacao' => $request->avaliacao]
                //     );
                // }
                AvaliacaoConteudo::updateOrCreate(
                    [
                        'user_id' => Auth::user()->id,
                        'curso_id' => $idCurso,
                        'aula_id' => $idAula,
                        'conteudo_id' => $idConteudo,
                    ],
                    ['avaliacao' => $request->avaliacao]
                );

                return response()->json(['success' => 'Avaliação enviada com sucesso!']);
            }
            else
            {
                return response()->json(['error' => 'Conteúdo não encontrado!']);
            }
        }
        else
        {
            return response()->json(['error' => 'Aula não encontrada!']);
        }
    }

    public function postEnviarComentarioConteudo($idCurso, $idAula, $idConteudo, Request $request)
    {
        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            if(Conteudo::where([['id', '=', $idConteudo]])->first() != null)
            {
                $comentario = ComentarioConteudo::create([
                    'user_id' => Auth::user()->id,
                    'curso_id' => $idCurso,
                    'aula_id' => $idAula,
                    'conteudo_id' => $idConteudo,
                    'comentario' => $request->comentario
                ]);

                $comentario->user = Auth::user();

                return response()->json(['success' => 'Comentário enviado com sucesso!', 'comentario' => $comentario]);
            }
            else
            {
                return response()->json(['error' => 'Conteúdo não encontrado!']);
            }
        }
        else
        {
            return response()->json(['error' => 'Aula não encontrada!']);
        }
    }

    public function getMensagensTransmissao($idCurso, $idAula, $idConteudo, Request $request)
    {
        $timestamp = $request->timestamp;

        if($timestamp == null)
        {
            if(MensagemTransmissao::orderBy('created_at', 'desc')->first() != null)
                $timestamp = MensagemTransmissao::orderBy('created_at', 'desc')->first()->created_at;
            else
                $timestamp = microtime(true);
        }

        $starttime = microtime(true);

        $mensagens = null;

        while(MensagemTransmissao::where('created_at', '>', $timestamp)->count() == 0)
        {
            usleep(15000);

            $endtime = microtime(true);

            $timediff = $endtime - $starttime;

            if($timediff > 30)
            {
                break;
            }
            elseif(MensagemTransmissao::where('created_at', '>', $timestamp)->count() > 0)
            {
                break;
            }
        }

        $mensagens = MensagemTransmissao::with('user')->where('created_at', '>', $timestamp)->get();

        $timestamp = MensagemTransmissao::orderBy('created_at', 'desc')->first()->created_at;

        return response()->json(['mensagens' => $mensagens, 'timestamp' => $timestamp]);
    }

    public function postEnviarMensagemTransmissao($idCurso, $idAula, $idConteudo, Request $request)
    {
        if(Aula::where([['id', '=', $idAula], ['curso_id', '=', $idCurso]])->first() != null)
        {
            if(Conteudo::where([['id', '=', $idConteudo], ['tipo', '=', 5]])->first() != null)
            {
                $mensagem = MensagemTransmissao::create([
                    'user_id' => Auth::user()->id,
                    'curso_id' => $idCurso,
                    'aula_id' => $idAula,
                    'conteudo_id' => $idConteudo,
                    'mensagem' => $request->mensagem
                ]);

                $mensagem->user = Auth::user();

                return response()->json(['success' => 'Mensagem enviada com sucesso!', 'mensagem' => $mensagem]);
            }
            else
            {
                return response()->json(['error' => 'Conteúdo não encontrado!']);
            }
        }
        else
        {
            return response()->json(['error' => 'Aula não encontrada!']);
        }
    }

    public function getExcluirComentarioConteudo($idCurso, $idAula, $idConteudo, $idComentario)
    {
        $comentario = ComentarioConteudo::where([['id', '=', $idComentario], ['conteudo_id', '=', $idConteudo]])->first();

        if($comentario != null)
        {
            if($comentario->user_id == Auth::user()->id || Curso::find($idCurso)->user_id == Auth::user()->id || strtolower(Auth::user()->permissao) == "z")
            {
                $comentario->delete();

                return response()->json(['success' => 'Comentário excluido com sucesso!']);
            }
            else
            {
                return response()->json(['error' => 'Ação não permitida!']);
            }
        }
        else
        {
            return response()->json(['error' => 'Comentário não encontrado!']);
        }
    }

    public function getCertificado($idCurso)
    {
        if(Curso::find($idCurso) == null)
        {
            return response()->view('errors.404');
        }

        // if(ConteudoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $idCurso]])->count() < Conteudo::where([['curso_id', '=', $idCurso], ['obrigatorio', '=', 1]])->count())
        if(CursoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $idCurso]])->first() == null)
        {
            return response()->view('errors.404');
        }

        $curso = Curso::find($idCurso);

        $user = Auth::user();

        if($user == null || $curso == null)
        {
            return response()->view('errors.404');
        }

        $dataConclusao = CursoCompleto::where([['user_id', '=', Auth::user()->id], ['curso_id', '=', $idCurso]])->first()->created_at->format('d/m/Y');

        return view('certificado')->with(compact('curso', 'user', 'dataConclusao'));
    }

}
<file_sep>/database/migrations/2019_08_08_111945_create_artigo_ajuda_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateArtigoAjudaTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('artigo_ajuda', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('user_id');
			$table->string('titulo');
			$table->text('conteudo');
			$table->text('categoria', 65535)->nullable();
			$table->text('marcadores', 65535)->nullable();
			$table->integer('visibilidade');
			$table->integer('status');
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('artigo_ajuda');
	}

}
<file_sep>/app/Http/Controllers/GamificacaoController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use Auth;

use App\User;
use App\Entities\GamificacaoUsuario;

use App\Entities\ConfiguracoesGamificacao\ConfiguracoesGamificacao;

class GamificacaoController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        $configuracoes_gamificacao = ConfiguracoesGamificacao::where([['user_id', '=', Auth::user()->id], ['escola_id', '=', Auth::user()->escola_id]])->first();

        if($configuracoes_gamificacao == null)
        {
            $configuracoes_gamificacao = ConfiguracoesGamificacao::create([
                'user_id' => Auth::user()->id,
                'escola_id' => Auth::user()->escola_id,
                'login_ativo' => false,
                'login_xp' => 25,
                'conclusao_conteudo_ativo' => false,
                'conclusao_conteudo_xp' => 10,
                'conclusao_aula_ativo' => false,
                'conclusao_aula_xp' => 50,
                'conclusao_curso_ativo' => false,
                'conclusao_curso_xp' => 100,
                'conclusao_teste_ativo' => false,
                'conclusao_teste_xp' => 30,
                'topico_ativo' => false,
                'topico_xp' => 15,
                'comentario_ativo' => false,
                'comentario_xp' => 5,
                'level_up_curso_ativo' => false,
                'level_up_curso' => 5,
                'level_up_conquista_ativo' => false,
                'level_up_conquista' => 15,
                'formula_level_ativo' => false,
                'formula_level' => null,
            ]);
        }

        return view('pages.gestao.gamificacao.index')->with( compact('configuracoes_gamificacao') );
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        //
        $request->request->add(['user_id' => Auth::user()->id]);

        $request->request->add(['escola_id' => Auth::user()->escola_id]);

        foreach ($request->all() as $key => $value) {
            if($value == 'on')
            {
                $request[$key] = true;
            }
        }

        if($request->has('login_ativo') == false)
        {
            $request->request->add(['login_ativo' => false]);
        }
        if($request->has('conclusao_conteudo_ativo') == false)
        {
            $request->request->add(['conclusao_conteudo_ativo' => false]);
        }
        if($request->has('conclusao_aula_ativo') == false)
        {
            $request->request->add(['conclusao_aula_ativo' => false]);
        }
        if($request->has('conclusao_curso_ativo') == false)
        {
            $request->request->add(['conclusao_curso_ativo' => false]);
        }
        if($request->has('conclusao_teste_ativo') == false)
        {
            $request->request->add(['conclusao_teste_ativo' => false]);
        }
        if($request->has('topico_ativo') == false)
        {
            $request->request->add(['topico_ativo' => false]);
        }
        if($request->has('comentario_ativo') == false)
        {
            $request->request->add(['comentario_ativo' => false]);
        }
        if($request->has('level_up_curso_ativo') == false)
        {
            $request->request->add(['level_up_curso_ativo' => false]);
        }
        if($request->has('level_up_conquista_ativo') == false)
        {
            $request->request->add(['level_up_conquista_ativo' => false]);
        }
        if($request->has('formula_level_ativo') == false)
        {
            $request->request->add(['formula_level_ativo' => false]);
        }

        // dd($request->all());

        ConfiguracoesGamificacao::updateOrCreate(
            ['user_id' => Auth::user()->id, 'escola_id' => Auth::user()->escola_id],
            $request->all()
        );

        // ConfiguracoesGamificacao::create($request->all());

        return redirect()->back()->with('success', 'Configurações de gamificação salvas com sucesso!');
    }

    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        //
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function edit($id)
    {
        //
        // ConfiguracoesGamificacao::create([
        //     'user_id' => Auth::user()->id,
        //     'escola_id' => Auth::user()->escola_id,
        //     'login_ativo' => $request->login_ativo,
        //     'login_xp' => $request->login_xp,
        //     'conclusao_aula_ativo' => $request->conclusao_aula_ativo,
        //     'conclusao_aula_xp' => $request->conclusao_aula_xp,
        //     'conclusao_curso_ativo' => $request->conclusao_curso_ativo,
        //     'conclusao_curso_xp' => $request->conclusao_curso_xp,
        //     'conclusao_teste_ativo' => $request->conclusao_teste_ativo,
        //     'conclusao_teste_xp' => $request->conclusao_teste_xp,
        //     'topico_ativo' => $request->topico_ativo,
        //     'topico_xp' => $request->topico_xp,
        //     'comentario_ativo' => $request->comentario_ativo,
        //     'comentario_xp' => $request->comentario_xp,
        //     'level_up_curso_ativo' => $request->level_up_curso_ativo,
        //     'level_up_curso' => $request->level_up_curso,
        //     'level_up_conquista_ativo' => $request->level_up_conquista_ativo,
        //     'level_up_conquista' => $request->level_up_conquista,
        //     'formula_level' => $request->formula_level,
        // ]);

    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
        //
    }
}
<file_sep>/app/Entities/Roteiros/Roteiros.php
<?php

namespace App\Entities\Roteiros;

use App\Entities\Roteiros\RoteirosTopico;
use App\User;
use Illuminate\Database\Eloquent\Model;

class Roteiros extends Model
{
    protected $table = "roteiros";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'titulo'
    ];



    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }



    public function topicos()
    {
        return $this->hasMany(RoteirosTopico::class, 'roteiro_id')->orderBy('id', 'asc');;
    }

}
<file_sep>/app/AvaliacaoInstrutor.php
<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Input;

class AvaliacaoInstrutor extends Model
{
    protected $table = 'avaliacoes_instrutor';
    
    //Preenchiveis
    protected $fillable = [
        'user_id',
        'instrutor_id',
        'avaliacao',
        'descricao',
    ];    

    // Protegidos
    protected $hidden = [
    ];

    //Padrões
    protected $attributes = [
        'descricao' => '',
    ];

    public function instrutor()
    {
        return $this->belongsTo('App\User', 'instrutor_id', 'id');
    }

    public function user()
    {
        return $this->belongsTo('App\User', 'user_id', 'id');
    }

}<file_sep>/database/migrations/2019_08_08_111945_create_cursos_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;

class CreateCursosTable extends Migration {

	/**
	 * Run the migrations.
	 *
	 * @return void
	 */
	public function up()
	{
		Schema::create('cursos', function(Blueprint $table)
		{
			$table->integer('id', true);
			$table->integer('escola_id');
			$table->integer('user_id');
			$table->string('titulo');
			$table->text('descricao_curta');
			$table->text('descricao');
			$table->string('capa');
			$table->integer('categoria');
			$table->integer('tipo');
			$table->boolean('visibilidade');
			$table->string('senha');
			$table->integer('status');
			$table->float('preco', 10, 0);
			$table->integer('periodo');
			$table->integer('vagas');
			$table->dateTime('data_publicacao')->nullable();
			$table->timestamps();
		});
	}


	/**
	 * Reverse the migrations.
	 *
	 * @return void
	 */
	public function down()
	{
		Schema::drop('cursos');
	}

}
<file_sep>/app/Http/Controllers/Habilidades/Api/HabilidadesController.php
<?php

namespace App\Http\Controllers\Habilidades\Api;

use App\Entities\HabilidadeUsuario\Api\Repository as HabilidadeUsuario;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class HabilidadesController extends Controller
{
  private $habilidadeUsuario;
  
  public function __construct(HabilidadeUsuario $habilidadeUsuario)
  {
    $this->habilidadeUsuario = $habilidadeUsuario;
  }
  
  public function UsuarioHabilidade($idUsuario, $idHabilidade, Request $request)
  {
    try {
      $this->habilidadeUsuario->store(['user_id' => $idUsuario, 'habilidade_id' => $idHabilidade, 'pontos' => $request->get('pontos')]);
      return response()->json(["success" => "Habilidade adicionada com sucesso!"]);
    } catch (\Exception $exception) {
      return response()->json(["error" => "Erro ao adicionar habilidade", "message:" => $exception->getMessage()]);
    }
  }
  
  public function UsuarioAuthHabilidade($idHabilidade, Request $request)
  {
    try {
      $this->habilidadeUsuario->store(['user_id' => Auth::user()->id, 'habilidade_id' => $idHabilidade, 'pontos' => $request->get('pontos')]);
      return response()->json(["success" => "Habilidade adicionada com sucesso!"]);
    } catch (\Exception $exception) {
      return response()->json(["error" => "Erro ao adicionar habilidade", "message:" => $exception->getMessage()]);
    }
  }
  
}
<file_sep>/app/Http/Controllers/ArtigosController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\Artigo;
use App\Categoria;

class ArtigosController extends Controller
{
    public function index ()
    {
        $artigos = Artigo::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $artigos->when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $is_admin = strtoupper(Auth::user()->permissao) == "Z";

        $artigos->when($is_admin == false, function ($query) {
            return $query->where('user_id', '=', Auth::user()->id);
        });

        $artigos = $artigos
        ->where([['status', '=', 1]])
        ->orderBy('id', 'DESC')
        ->get();

        return view('artigos.index')->with( compact('artigos') );
    }

    public function gestaoArtigos()
    {
        $artigos = Artigo::query();

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;

        $artigos->when($tem_pesquisa, function ($query) {
            return $query
            ->where('titulo', 'like', '%' . Input::get('pesquisa') . '%')
            ->orWhere('descricao', 'like', '%' . Input::get('pesquisa') . '%');
        });

        $is_admin = strtoupper(Auth::user()->permissao) == "Z";

        $artigos->when($is_admin == false, function ($query) {
            return $query->where('user_id', '=', Auth::user()->id);
        });

        $artigos = $artigos
        // ->where([['status', '=', 1]])
        ->orderBy('id', 'DESC')
        ->get();

        return view('gestao.artigos.index')->with( compact('artigos') );
    }

    public function lerArtigo($artigo_id, $sluged_title)
    {
        if(Artigo::find($artigo_id) != null)
        {
            $artigo = Artigo::find($artigo_id);

            return view('gestao.artigos.ler-artigo')->with( compact('artigo') );
        }
        else
        {
            return redirect("404");
            // return redirect()->route('gestao.artigos.index')->with('error', 'Artigo não encontrado!');
        }
    }

    public function create()
    {
        $categorias = Categoria::where([['tipo', '=', 4]])->get();

        return view('gestao.artigos.novo-artigo')->with( compact('categorias') );
    }

    public function store(Request $request)
    {
        // dd($request);

        if(isset($request->arquivo_capa))
        {
            $originalName = mb_strtolower( $request->arquivo_capa->getClientOriginalName(), 'utf-8' );

            $fileExtension = \File::extension($request->arquivo_capa->getClientOriginalName());
            $newFileNameArquivo =  md5( $request->arquivo_capa->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

            $pathArquivo = $request->arquivo_capa->storeAs('artigos', $newFileNameArquivo, 'public_uploads');

            if(!\Storage::disk('public_uploads')->put($pathArquivo, file_get_contents($request->arquivo_capa)))
            {
                // return redirect()->back()->with('error', 'Não foi possível fazer upload da capa, por favor tente novamente!');

                \Request::session()->flash('error', 'Não foi possível fazer upload da capa, por favor tente novamente!');
            }
        }
        else
        {
            return redirect()->back()->with('error', 'Você deve anexar uma capa para seu artigo!');
        }

        Artigo::create([
            'user_id' => \Auth::user()->id,
            'escola_id' => \Auth::user()->escola_id,
            'titulo' => $request->titulo,
            'subtitulo' => $request->subtitulo,
            'descricao' => $request->descricao,
            'conteudo' => $request->conteudo,
            'capa' => $newFileNameArquivo,
            'status' => $request->status == null ? 0 : $request->status,
        ]);

        // return redirect()->back()->with('message', 'Artigo criado com sucesso!');
        return redirect()->route('gestao.artigos.index')->with('message', 'Artigo criado com sucesso!');
    }

    public function update(Request $request)
    {
        // dd($request);

        if(Artigo::find($request->artigo_id) != null)
        {
            $artigo = Artigo::find($request->artigo_id);

            if(isset($request->arquivo_capa))
            {
                $originalName = mb_strtolower( $request->arquivo_capa->getClientOriginalName(), 'utf-8' );

                $fileExtension = \File::extension($request->arquivo_capa->getClientOriginalName());
                $newFileNameArquivo =  md5( $request->arquivo_capa->getClientOriginalName() . date("Y-m-d H:i:s") . time() ) . '.' . $fileExtension;

                $pathArquivo = $request->arquivo_capa->storeAs('artigos', $newFileNameArquivo, 'public_uploads');

                if(!\Storage::disk('public_uploads')->put($pathArquivo, file_get_contents($request->arquivo_capa)))
                {
                    \Session::flash('error', 'Não foi possível fazer upload de seu conteúdo!');
                }
                else
                {
                    if(\Storage::disk('public_uploads')->has('artigos/' . $artigo->capa))
                    {
                        \Storage::disk('public_uploads')->delete('artigos/' . $artigo->capa);
                    }

                    $artigo->update([
                        'capa' => $newFileNameArquivo,
                    ]);
                }
            }

            $artigo->update([
                'titulo' => $request->titulo,
                'subtitulo' => $request->subtitulo,
                'descricao' => $request->descricao,
                'conteudo' => $request->conteudo,
                'status' => $request->status
            ]);

            return redirect()->back()->with('message', 'Artigo atualizado com sucesso!');
        }
        else
        {
            return response()->json(["response" => false, "data" => "Artigo não encontrado!", 404]);
        }
    }

    public function editarArtigo($artigo_id)
    {
        if(Artigo::find($artigo_id) != null)
        {
            $artigo = Artigo::find($artigo_id);

            $categorias = Categoria::where([['tipo', '=', 4]])->get();

            return view('gestao.artigos.editar-artigo')->with( compact('artigo', 'categorias') );
        }
        else
        {
            return redirect()->route('gestao.artigos.index')->with('error', 'Artigo não encontrado!');
        }
    }

    public function getArtigo($artigo_id)
    {
        if(Artigo::find($artigo_id) != null)
        {
            $artigo = Artigo::find($artigo_id);

            return response()->json(["response" => true, "data" => "Artigo carregado com sucesso!", 'artigo' => $artigo ]);
        }
        else
        {
            return response()->json(["response" => false, "data" => "Artigo não encontrado!", 404]);
        }
    }

    public function delete(Request $request)
    {
        // dd($request);

        if(Artigo::find($request->artigo_id) != null)
        {
            $artigo = Artigo::find($request->artigo_id);

            if(\Storage::disk('public_uploads')->has('artigos/' . $artigo->capa))
            {
                \Storage::disk('public_uploads')->delete('artigos/' . $artigo->capa);
            }

            $artigo->delete();

            return response()->json(["response" => true, "data" => "Artigo excluído com sucesso!", 200]);
        }
        else
        {
            return response()->json(["response" => false, "data" => "Artigo não encontrado!", 404]);
        }
    }

}
<file_sep>/app/Http/Controllers/RecompensasExtraJogo/Admin/RecompensasExtraJogoController.php
<?php

namespace App\Http\Controllers\RecompensasExtraJogo\Admin;


use App\Entities\RecompensaExtraJogo\RecompensaExtraJogo;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Input;

class RecompensasExtraJogoController extends Controller
{

    public function index(Request $request)
    {
        $recompensasExtraJogo = RecompensaExtraJogo::orderBy('id', 'DESC')->paginate(6);

        $tem_pesquisa = Input::has('pesquisa') ? (Input::get('pesquisa') != null && Input::get('pesquisa') != "") : false;
        if($tem_pesquisa)
        {
            $recompensasExtraJogo = RecompensaExtraJogo::where('titulo', 'like', '%' . Input::get('pesquisa') . '%')->paginate(6);
        }

        return view('pages.recompensas-extra-jogo.admin.index', compact('recompensasExtraJogo'));
    }

    public function store(Request $request)
    {
        $this->validate($request, [
            'titulo'    => 'required'
        ]);
        $values = $request->all();
        $values['user_id'] = Auth::user()->id;

        RecompensaExtraJogo::create($values);
        return redirect()->route('gestao.recompensas-extra-jogo.listar')->with('message', 'Recompensa Extra-Jogo cadastrado com sucesso!');
    }

    public function fetch($id, Request $request)
    {
        $recompensaExtraJogo = RecompensaExtraJogo::find($id);

        return $recompensaExtraJogo->toJson();
    }       

    public function update($id, Request $request)
    {
        $this->validate($request, [
            'titulo'    => 'required'
        ]);
        $values = $request->all();
        RecompensaExtraJogo::find($id)->update($values);

        return redirect()->route('gestao.recompensas-extra-jogo.listar')->with('message', 'Recompensa Extra-Jogo atualizado com sucesso!');
    }


    public function delete($id)
    {
        RecompensaExtraJogo::find($id)->delete();

        return redirect()->route('gestao.recompensas-extra-jogo.listar')->with('message', 'Recompensa Extra-Jogo excluído com sucesso!');
    }

}
<file_sep>/app/Entities/Agenda/Agenda.php
<?php

namespace App\Entities\Agenda;

use Illuminate\Database\Eloquent\Model;

class Agenda extends Model
{
    protected $table = 'agendas';
    
    //Preenchiveis
    protected $fillable = [
        'data_inicial',
        'data_final',
        'titulo',
        'descricao',
        'cor',
        'user_id'
    ];
}
<file_sep>/app/Entities/Playlist/Playlist.php
<?php

namespace App\Entities\Playlist;

use App\Entities\Audio\Audio;
use App\User;
use Illuminate\Database\Eloquent\Model;

class Playlist extends Model
{
    protected $table = "playlists";

    //Preenchiveis
    protected $fillable = [
        'user_id',
        'titulo'
    ];

    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }


    public function audios()
    {
        return $this->belongsToMany(Audio::class, 'playlist_audios', 'playlist_id');
    }




    public function getArtistAttribute()
    {
        $user = User::where('id', $this->attributes['artist'])->select('name')->first();
        return $user->name;
    }

    public function getCreatedAtAttribute($date)
    {
        return ucfirst(\Carbon\Carbon::createFromFormat('Y-m-d H:i:s', $date)->diffForHumans());
    }

}
<file_sep>/app/Http/Controllers/API/GlossaryController.php
<?php

namespace App\Http\Controllers\API;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use App\Entities\Glossario\Repository;

class GlossaryController extends Controller
{
  protected $repository;

  public function __construct(Repository $repository) {
    $this->repository = $repository;
  }

  public function show($letter = "A")
  {
    if (strlen($letter) == 1) {
        $glossarios = $this->repository->all($letter);
    } else {
        $glossarios = $this->repository->search($letter);
    }

    return response()->json(["data" => $glossarios]);

  }
}
<file_sep>/app/Http/Controllers/CodigoAcessoEscolaController.php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use Auth;
use Redirect;
use Session;
use Carbon\Carbon;

use App\User;
use App\CodigoAcessoEscola;
use App\Escola;
use App\Turma;

class CodigoAcessoEscolaController extends Controller
{
    public function index()
    {
        $escola = Escola::find(Auth::user()->escola_id);

        if($escola == null)
        {
            return redirect()->back()->withErrors("Escola não encontrada!");
        }

        $codigosAcesso = CodigoAcessoEscola::where('escola_id', $escola->id)->get();

        $turmas = Turma::whereHas('professor', function($q) use ($escola) {
            $q->where('escola_id', '=', $escola->id);
        })->get();

        $alunos = User::where([['escola_id', $escola->id], ['permissao', "A"]])->get();

        return view('gestao.escola.codigos')->with(compact( 'codigosAcesso', 'turmas', 'escola', 'alunos' ));
    }

    public function postGerarCodigosAcesso($idEscola, Request $request)
    {
        if(Escola::find($idEscola) != null)
        {
            $escola = Escola::find($idEscola);

            if(strrpos(mb_strtoupper(Auth::user()->permissao, 'UTF-8'), "Z") !== false
                && Auth::user()->id != $escola->user_id //Checa se é dono da escola
                && Auth::user()->escola_id != $escola->id) //Checa se faz parte da escola
            {
                return redirect()->back()->withErrors("Você não tem permissão para realizar esta ação!");
            }

            if($request->turma_id != null ? (Turma::find($request->turma_id) == null) : false)
            {
                return redirect()->back()->withErrors("Turma não encontrada!");
            }

            if($request->quantidade <= 0)
            {
                return redirect()->back()->withErrors("Você deve gerar 1 ou mais códigos!");
            }

            if(($escola->limite_alunos - User::where([['escola_id', $idEscola], ['permissao', 'A']])->count()) <= 0)
            {
                return redirect()->back()->withErrors("Você não pode gerar mais códigos!");
            }

            if($request->quantidade > ($escola->limite_alunos - User::where([['escola_id', $idEscola], ['permissao', 'A']])->count() - CodigoAcessoEscola::where([['escola_id', $escola->id], ['aluno_id', null]])->count()))
            {
                return redirect()->back()->withErrors("Você não pode gerar mais códigos que seu limite de alunos!");
            }

            if($request->quantidade > 250)
            {
                return redirect()->back()->withErrors("Por favor tente gerar uma menor quantidade de códigos, e se precisar de mais gere novamente.");
            }

            $count = 0;

            for ($i = 0; $i < $request->quantidade; $i++)
            {
                $token = self::getTokenRandomico();

                if($token == null)
                {
                    continue;
                }

                CodigoAcessoEscola::create([
                    'escola_id' => $idEscola,
                    'turma_id' => $request->turma_id,
                    'codigo' => mb_strtoupper($token, 'UTF-8')
                ]);

                $count ++;
            }

            Session::flash("message", 'Códigos de acesso gerados com sucesso, agora basta passar aos seus alunos. (' . $count . ' códigos gerados)');
            return redirect()->back();
        }
        else
        {
            return redirect()->back()->withErrors("Escola não encontrada!");
        }
    }

    public function postExcluirCodigoAcesso($idEscola, $idCodigo)
    {
        $escola = Escola::find($idEscola);

        if(Escola::find($idEscola) == null)
        {
            return redirect()->back()->withErrors("Escola não encontrada!");
        }

        if(strrpos(mb_strtoupper(Auth::user()->permissao, 'UTF-8'), "Z") !== false
            && Auth::user()->id != $escola->user_id //Checa se é dono da escola
            && Auth::user()->escola_id != $escola->id) //Checa se faz parte da escola
        {
            return redirect()->back()->withErrors("Você não tem permissão para realizar esta ação!");
        }

        if(CodigoAcessoEscola::find($idCodigo) != null)
        {
            CodigoAcessoEscola::find($idCodigo)->delete();

            return response()->json(["success" => "Código de acesso excluido com sucesso!"]);
        }
        else
        {
            return response()->json(["error" => "Código de acesso não encontrada!"]);
        }
    }

    public function getTokenRandomico()
    {
        $step = 0;

        do
        {
            if($step < 10)
            {
                $token = \HelperClass::RandomString(4);
            }
            else if($step < 20)
            {
                $token = \HelperClass::RandomString(6);
            }
            else if($step < 30)
            {
                $token = \HelperClass::RandomString(10);
            }
            else if($step < 40)
            {
                $token = \HelperClass::RandomString(12);
            }
            else
            {
                $token = \HelperClass::RandomString(15);
            }

            $step ++;

        } while(CodigoAcessoEscola::where('codigo', '=', $token)->exists() && $step < 50);

        if($step >= 50)
        {
            return null;
        }
        else
        {
            return $token;
        }
    }

}
