main.py

from days.day_069.files.helpers import *


def day_069():
    title("BLOG: ADDING USERS")
    template_folder_path = os.path.join(os.path.dirname(__file__), "files", "templates")
    static_folder_path = os.path.join(os.path.dirname(__file__), "files", "static")
    app = Flask(
        __name__, template_folder=template_folder_path, static_folder=static_folder_path
    )
    load_dotenv()
    app.config["SECRET_KEY"] = os.getenv("SOME_SECRET_KEY_FOR_FLASK")
    ckeditor = CKEditor(app)
    Bootstrap5(app)

    # Configure Flask-Login
    login_manager = LoginManager()
    login_manager.init_app(app)

    @login_manager.user_loader
    def load_user(user_id):
        return db.get_or_404(User, user_id)

    # For adding profile images to the comment section
    def gravatar_url(email, size=100, rating="g", default="retro", force_default=False):
        hash_value = md5(email.lower().encode("utf-8")).hexdigest()
        return f"https://www.gravatar.com/avatar/{hash_value}?s={size}&d={default}&r={rating}&f={force_default}"

    # Register the gravatar_url function as a Jinja2 filter
    app.jinja_env.filters["gravatar"] = gravatar_url

    # gravatar = Gravatar(
    #     app,
    #     size=100,
    #     rating="g",
    #     default="retro",
    #     force_default=False,
    #     force_lower=False,
    #     use_ssl=False,
    #     base_url=None,
    # )

    # CREATE DATABASE
    class Base(DeclarativeBase):
        pass

    app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///posts.db"
    db = SQLAlchemy(model_class=Base)
    db.init_app(app)

    # CONFIGURE TABLES
    class BlogPost(db.Model):
        __tablename__ = "blog_posts"
        id: Mapped[int] = mapped_column(Integer, primary_key=True)
        # Create Foreign Key, "users.id" the users refers to the tablename of User.
        author_id: Mapped[int] = mapped_column(Integer, db.ForeignKey("users.id"))
        # Create reference to the User object. The "posts" refers to the posts property in the User class.
        author = relationship("User", back_populates="posts")
        title: Mapped[str] = mapped_column(String(250), unique=True, nullable=False)
        subtitle: Mapped[str] = mapped_column(String(250), nullable=False)
        date: Mapped[str] = mapped_column(String(250), nullable=False)
        body: Mapped[str] = mapped_column(Text, nullable=False)
        img_url: Mapped[str] = mapped_column(String(250), nullable=False)
        # Parent relationship to the comments
        comments = relationship("Comment", back_populates="parent_post")

    # Create a User table for all your registered users
    class User(UserMixin, db.Model):
        __tablename__ = "users"
        id: Mapped[int] = mapped_column(Integer, primary_key=True)
        email: Mapped[str] = mapped_column(String(100), unique=True)
        password: Mapped[str] = mapped_column(String(100))
        name: Mapped[str] = mapped_column(String(100))
        # This will act like a list of BlogPost objects attached to each User.
        # The "author" refers to the author property in the BlogPost class.
        posts = relationship("BlogPost", back_populates="author")
        # Parent relationship: "comment_author" refers to the comment_author property in the Comment class.
        comments = relationship("Comment", back_populates="comment_author")

    # Create a table for the comments on the blog posts
    class Comment(db.Model):
        __tablename__ = "comments"
        id: Mapped[int] = mapped_column(Integer, primary_key=True)
        text: Mapped[str] = mapped_column(Text, nullable=False)
        # Child relationship:"users.id" The users refers to the tablename of the User class.
        # "comments" refers to the comments property in the User class.
        author_id: Mapped[int] = mapped_column(Integer, db.ForeignKey("users.id"))
        comment_author = relationship("User", back_populates="comments")
        # Child Relationship to the BlogPosts
        post_id: Mapped[str] = mapped_column(Integer, db.ForeignKey("blog_posts.id"))
        parent_post = relationship("BlogPost", back_populates="comments")

    with app.app_context():
        db.create_all()

    # Create an admin-only decorator
    def admin_only(f):
        @wraps(f)
        def decorated_function(*args, **kwargs):
            # If id is not 1 then return abort with 403 error
            if current_user.id != 1:
                return abort(403)
            # Otherwise continue with the route function
            return f(*args, **kwargs)

        return decorated_function

    # Register new users into the User database
    @app.route("/register", methods=["GET", "POST"])
    def register():
        form = RegisterForm()
        if form.validate_on_submit():

            # Check if user email is already present in the database.
            result = db.session.execute(
                db.select(User).where(User.email == form.email.data)
            )
            user = result.scalar()
            if user:
                # User already exists
                flash("You've already signed up with that email, log in instead!")
                return redirect(url_for("login"))

            hash_and_salted_password = generate_password_hash(
                form.password.data, method="pbkdf2:sha256", salt_length=8
            )
            new_user = User(
                email=form.email.data,
                name=form.name.data,
                password=hash_and_salted_password,
            )
            db.session.add(new_user)
            db.session.commit()
            # This line will authenticate the user with Flask-Login
            login_user(new_user)
            return redirect(url_for("get_all_posts"))
        return render_template("register.html", form=form, current_user=current_user)

    @app.route("/login", methods=["GET", "POST"])
    def login():
        form = LoginForm()
        if form.validate_on_submit():
            password = form.password.data
            result = db.session.execute(
                db.select(User).where(User.email == form.email.data)
            )
            # Note, email in db is unique so will only have one result.
            user = result.scalar()
            # Email doesn't exist
            if not user:
                flash("That email does not exist, please try again.")
                return redirect(url_for("login"))
            # Password incorrect
            elif not check_password_hash(user.password, password):
                flash("Password incorrect, please try again.")
                return redirect(url_for("login"))
            else:
                login_user(user)
                return redirect(url_for("get_all_posts"))

        return render_template("login.html", form=form, current_user=current_user)

    @app.route("/logout")
    def logout():
        logout_user()
        return redirect(url_for("get_all_posts"))

    @app.route("/")
    def get_all_posts():
        result = db.session.execute(db.select(BlogPost))
        posts = result.scalars().all()
        return render_template("index.html", all_posts=posts, current_user=current_user)

    # Add a POST method to be able to post comments
    @app.route("/post/<int:post_id>", methods=["GET", "POST"])
    def show_post(post_id):
        requested_post = db.get_or_404(BlogPost, post_id)
        # Add the CommentForm to the route
        comment_form = CommentForm()
        # Only allow logged-in users to comment on posts
        if comment_form.validate_on_submit():
            if not current_user.is_authenticated:
                flash("You need to login or register to comment.")
                return redirect(url_for("login"))

            new_comment = Comment(
                text=comment_form.comment_text.data,
                comment_author=current_user,
                parent_post=requested_post,
            )
            db.session.add(new_comment)
            db.session.commit()
        return render_template(
            "post.html",
            post=requested_post,
            current_user=current_user,
            form=comment_form,
            gravatar=gravatar_url,
        )

    # Use a decorator so only an admin user can create new posts
    @app.route("/new-post", methods=["GET", "POST"])
    @admin_only
    def add_new_post():
        form = CreatePostForm()
        if form.validate_on_submit():
            new_post = BlogPost(
                title=form.title.data,
                subtitle=form.subtitle.data,
                body=form.body.data,
                img_url=form.img_url.data,
                author=current_user,
                date=date.today().strftime("%B %d, %Y"),
            )
            db.session.add(new_post)
            db.session.commit()
            return redirect(url_for("get_all_posts"))
        return render_template("make-post.html", form=form, current_user=current_user)

    # Use a decorator so only an admin user can edit a post
    @app.route("/edit-post/<int:post_id>", methods=["GET", "POST"])
    def edit_post(post_id):
        post = db.get_or_404(BlogPost, post_id)
        edit_form = CreatePostForm(
            title=post.title,
            subtitle=post.subtitle,
            img_url=post.img_url,
            author=post.author,
            body=post.body,
        )
        if edit_form.validate_on_submit():
            post.title = edit_form.title.data
            post.subtitle = edit_form.subtitle.data
            post.img_url = edit_form.img_url.data
            post.author = current_user
            post.body = edit_form.body.data
            db.session.commit()
            return redirect(url_for("show_post", post_id=post.id))
        return render_template(
            "make-post.html", form=edit_form, is_edit=True, current_user=current_user
        )

    # Use a decorator so only an admin user can delete a post
    @app.route("/delete/<int:post_id>")
    @admin_only
    def delete_post(post_id):
        post_to_delete = db.get_or_404(BlogPost, post_id)
        db.session.delete(post_to_delete)
        db.session.commit()
        return redirect(url_for("get_all_posts"))

    @app.route("/about")
    def about():
        return render_template("about.html", current_user=current_user)

    @app.route("/contact")
    def contact():
        return render_template("contact.html", current_user=current_user)

    if __name__ == "days.day_069.main":
        app.run(debug=True, use_reloader=False)