text: //Carregando módulos
  const express = require("express");
  const handlebars = require("express-handlebars");
  const bodyParser = require("body-parser");
  const app = express();
  const mongoose = require("mongoose");
  
  //Importando rotas definidas em admin.js, costuma-se utilizar o mesmo nome do arquivo
  const admin = require("./routes/admin");
  
  //Importando rotas definidas em usuario.js
  const usuario = require("./routes/usuario");
  
  //Módulo incluso no node para manipular diretórios/pastas
  const path = require("path");
  
  //Express-session
  const session = require("express-session");
  
  // Importa pacote para exibir mensagens com o connect-flash
  const flash = require("connect-flash");
  
  //Model de Postagens
  require("./models/Postagem");
  
  //Declarando model
  const Postagem = mongoose.model("postagens");
  
  //Carregando módulo de Categorias
  require("./models/Categoria");
  const Categoria = mongoose.model("categorias");
  
  // Carrega o passport
  const passport = require("passport");
  
  // Carrega arquivo de configuração de autenticação e define que será usado o passport
  require("./config/auth")(passport);
  
  // Carrega arquivo de conexão ao banco de dados
  const db = require("./config/db");
  
  //Configurações
  
  //Sessão
  app.use(
    session({
      secret: "cursodenode", //tipo uma chave para gerar um sessão, deve ser segura
      resave: true,
      saveUninitialized: true,
    })
  );
  
  // Configura inicialização e uso do passport para autenticação
  app.use(passport.initialize());
  app.use(passport.session());
  
  app.use(flash());
  
  // Middleware
  app.use((req, res, next) => {
    // Definição das variáveis globais, deve-se utilizar ".locals"
  
    // Variáveis para exibição de mensagens:
    res.locals.success_msg = req.flash("success_msg");
    res.locals.error_msg = req.flash("error_msg");
  
    // Variável para exibição de mensagens de erro na parte de login ->
    res.locals.error = req.flash("error");
  
    /*
    Variável para armazenar dados do usuário logado.
    O req.user é criado automaticamente pelo passport
    O null serve para o caso em que não haja nenhum usuário logado.
    */
    res.locals.user = req.user || null;
  
    // Ao passar por um middleware, deve-se chamar a função next para sair do middleware, ou a aplicação travará no middleware
    next();
  });
  
  //Body Parser
  
  app.use(bodyParser.urlencoded({ extended: true }));
  app.use(bodyParser.json());
  
  //Handlebars
  app.engine("handlebars", handlebars({ defaultLayout: "main" }));
  app.set("view engine", "handlebars");
  
  //Mongoose
  mongoose.Promise = global.Promise;
  mongoose
    .connect(db.mongoURI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
      useFindAndModify: false,
      useCreateIndex: true,
    })
    .then(() => {
      console.log("Conectado ao mongo");
    })
    .catch((erro) => {
      console.log("Erro ao se conectar ao mongo: " + erro);
    });
  
  //Public - indicando a pasta que contém os arquivos estáticos
  app.use(express.static("public"));
  
  //Rotas
  app.get("/", (req, res) => {
    Postagem.find()
      .populate("categoria")
      .sort({ data: "desc" })
      .lean()
      .then((postagens) => {
        //o populate deve pegar o atributo do model Postagem (categoria) e não o nome da collection
        res.render("index", { postagens: postagens });
      })
      .catch((erro) => {
        req.flash("error_msg", "Houve um erro interno: " + erro);
        res.redirect("/404");
      });
  });
  
  //Ao pegar uma rota, define-se um "prefixo"/rota para acessar as rotas definidas no outro arquivo
  
  app.get("/postagem/:slug", (req, res) => {
    Postagem.findOne({ slug: req.params.slug })
      .lean()
      .then((postagem) => {
        if (postagem) {
          res.render("postagem/index", { postagem: postagem });
        } else {
          req.flash("error_msg", "Essa postagem não existe");
          res.redirect("/");
        }
      })
      .catch((erro) => {
        req.flash("error_msg", "Houve um erro interno");
        res.redirect("/");
      });
  });
  
  //Usa as views definidas na pasta admin
  app.use("/admin", admin);
  
  //Usa as views definidas na pasta usuarios
  app.use("/usuarios", usuario);
  
  //Rota das Categorias
  app.get("/categorias", (req, res) => {
    Categoria.find()
      .lean()
      .then((categorias) => {
        res.render("categorias/index", { categorias: categorias });
      })
      .catch((erro) => {
        req.flash(
          "error_msg",
          "Houve um erro interno ao listar as categorias: " + erro
        );
      });
  });
  
  //Rota das postagens de uma categoria
  app.get("/categorias/:slug", (req, res) => {
    Categoria.findOne({ slug: req.params.slug })
      .lean()
      .then((categoria) => {
        if (categoria) {
          Postagem.find({ categoria: categoria._id })
            .lean()
            .then((postagens) => {
              res.render("categorias/postagens", {
                postagens: postagens,
                categoria: categoria,
              });
            })
            .catch((erro) => {
              req.flash(
                "error_msg",
                "Houve um erro ao listar os posts dessa categoria: " + erro
              );
              res.redirect("/");
            });
        } else {
          req.flash("error_msg", "Esta categoria não existe");
          res.redirect("/");
        }
      })
      .catch((erro) => {
        req.flash(
          "error_msg",
          "Houve um erro interno ao carregar a página dessa categoria: " + erro
        );
        res.redirect("/");
      });
  });
  
  //Rota de Erro
  app.get("/404", (req, res) => {
    res.send("Erro 404!");
  });
  
  //Outros
  
  //Uma constante para guardar qual a porta que será usada para executar a aplicação
  const PORT = process.env.PORT || 8081;
  // "process.env.PORT" -> pega a variável de ambiente que o Heroku irá definir
  
  // Método para definir a porta em que a aplicação será executada
  app.listen(PORT, () => {
    console.log("Servidor rodando na porta " + PORT);
  });
  