Query posts.

Author: toddbirchard

sqlalchemy_tutorial/part3_relationships/__init__.py

@@ -1,9 +1,9 @@
 from database import session
 from sqlalchemy_tutorial.part3_relationships.models import Comment, Post, User
 
-from .joins import list_all_comments
+from .joins import get_all_comments, get_all_posts
 from .objects import create_comment_objects, create_post_object, create_user_objects
-from .orm import create_comment, create_new_user, create_post
+from .orm import create_comment, create_user, create_post
 
 
 def create_relationships():
@@ -14,22 +14,30 @@ def create_relationships():
     """
     # Create admin & regular user
     admin_user, regular_user = create_user_objects()
-    admin_user = create_new_user(session, admin_user)
-    regular_user = create_new_user(session, regular_user)
+    admin_user = create_user(session, admin_user)
+    regular_user = create_user(session, regular_user)
 
     # Create post object and add to database
-    post = create_post_object(admin_user)
-    post = create_post(session, post, admin_user)
+    post_1, post_2 = create_post_object(admin_user)
+    post_1 = create_post(session, post_1)
+    post_2 = create_post(session, post_2)
 
-    # Create three comments on the same post
+    # Create comments on the same post
     (
         comment_1,
         comment_2,
         comment_3,
-    ) = create_comment_objects(regular_user, post)
-    create_comment(session, regular_user, comment_1)
-    create_comment(session, regular_user, comment_2)
-    create_comment(session, regular_user, comment_3)
+        comment_4,
+        comment_5,
+    ) = create_comment_objects(regular_user, admin_user, post_1, post_2)
+    create_comment(session, comment_1)
+    create_comment(session, comment_2)
+    create_comment(session, comment_3)
+    create_comment(session, comment_4)
+    create_comment(session, comment_5)
 
-    # Show post with comments:
-    list_all_comments(session)
+    # One-to-many JOIN for a given user
+    get_all_posts(session, admin_user)
+
+    # Show posts with comments:
+    get_all_comments(session)

sqlalchemy_tutorial/part3_relationships/joins.py

@@ -2,10 +2,45 @@
 from sqlalchemy.orm import Session
 
 from logger import LOGGER
-from sqlalchemy_tutorial.part3_relationships.models import Comment, Post
+from sqlalchemy_tutorial.part3_relationships.models import Comment, Post, User
 
 
-def list_all_comments(session: Session):
+def get_all_posts(session: Session, admin_user: User):
+    """
+    Fetch all posts belonging to an author user.
+
+    :param session: SQLAlchemy database session.
+    :type session: Session
+    :param admin_user: Author of blog posts.
+    :type admin_user: User
+
+    :return: None
+    """
+    posts = (
+        session.query(Post)
+        .join(User, Post.author_id == User.id)
+        .filter_by(username=admin_user.username)
+        .all()
+    )
+    for post in posts:
+        post_record = {
+            "post_id": post.id,
+            "title": post.title,
+            "summary": post.summary,
+            "status": post.status,
+            "feature_image": post.feature_image,
+            "author": {
+                "id": post.author_id,
+                "username": post.author.username,
+                "first_name": post.author.first_name,
+                "last_name": post.author.last_name,
+                "role": post.author.role,
+            },
+        }
+        LOGGER.info(post_record)
+
+
+def get_all_comments(session: Session):
     """
     Fetch all comments and join with their parent posts.
 

sqlalchemy_tutorial/part3_relationships/objects.py

@@ -32,7 +32,7 @@ def create_user_objects() -> Tuple[User, User]:
     return admin_user, regular_user
 
 
-def create_post_object(admin_user: User) -> Post:
+def create_post_object(admin_user: User) -> Tuple[Post, Post]:
     """
     Set up post to add to database.
 
@@ -41,7 +41,7 @@ def create_post_object(admin_user: User) -> Post:
 
     :return: Post
     """
-    return Post(
+    post_1 = Post(
         author_id=admin_user.id,
         slug="fake-post-slug",
         title="Fake Post Title",
@@ -52,24 +52,40 @@ def create_post_object(admin_user: User) -> Post:
                     cheese gouda. Rubber cheese cheese and wine cheeseburger cheesy grin paneer paneer taleggio caerphilly. \
                     Edam mozzarella.",
     )
+    post_2 = Post(
+        author_id=admin_user.id,
+        slug="an-additional-post",
+        title="Yet Another Post Title",
+        status="published",
+        summary="An in-depth exploration into writing your second blog post.",
+        feature_image="https://hackersandslackers-cdn.storage.googleapis.com/2021/01/[email protected]",
+        body="Smelly cheese cheese slices fromage. Pepper jack taleggio monterey jack cheeseburger pepper jack \
+              swiss everyone loves. Cheeseburger say cheese brie fromage frais swiss when the cheese comes out \
+              everybody's happy babybel cheddar. Cheese and wine cheesy grin",
+    )
+    return post_1, post_2
 
 
 def create_comment_objects(
-    regular_user: User, post: Post
-) -> Tuple[Comment, Comment, Comment]:
+    regular_user: User, admin_user: User, post_1: Post, post_2: Post
+) -> Tuple[Comment, Comment, Comment, Comment, Comment]:
     """
-    Set up 3 comments to be added to published post.
+    Set up comments to be added to published post.
 
     :param regular_user: User to serve as comment author.
     :type regular_user: User
-    :param post: Blog post to be created.
-    :type post: Post
+    :param admin_user: User to serve as post or comment author.
+    :type admin_user: User
+    :param post_1: First blog post to associate comments with.
+    :type post_1: Post
+    :param post_2: First blog post to associate comments with.
+    :type post_2: Post
 
     :return: Tuple[Comment, Comment, Comment]
     """
     comment_1 = Comment(
         user_id=regular_user.id,
-        post_id=post.id,
+        post_id=post_1.id,
         body="This post about SQLAlchemy is awful. You didn't even bother to explain how to install Python, \
               which is where I (and so many others) got stuck. Plus, your code doesn't even work!! \
               I cloned your code and it keeps giving me `environment variable` errors... \
@@ -78,15 +94,27 @@ def create_comment_objects(
     )
     comment_2 = Comment(
         user_id=regular_user.id,
-        post_id=post.id,
+        post_id=post_1.id,
         body="By the way, you SUCK!!! I HATE you!!!! I have a project due tomorrow, how am I supposed to finish \
              if you won't do my job for me, you selfish prick?!?!",
         upvotes=5,
     )
     comment_3 = Comment(
         user_id=regular_user.id,
-        post_id=post.id,
+        post_id=post_2.id,
         body="YOU RUINED MY LIFE!!!!",
         upvotes=5,
     )
-    return comment_1, comment_2, comment_3
+    comment_4 = Comment(
+        user_id=admin_user.id,
+        post_id=post_1.id,
+        body="Please stop bullying me :(",
+        upvotes=11,
+    )
+    comment_5 = Comment(
+        user_id=admin_user.id,
+        post_id=post_2.id,
+        body="I was just trying to help.",
+        upvotes=514,
+    )
+    return comment_1, comment_2, comment_3, comment_4, comment_5

sqlalchemy_tutorial/part3_relationships/orm.py

@@ -8,7 +8,7 @@
 from sqlalchemy_tutorial.part3_relationships.models import Comment, Post, User
 
 
-def create_new_user(session: Session, user: User) -> User:
+def create_user(session: Session, user: User) -> User:
     """
     Create a new user if username isn't already taken.
 
@@ -20,13 +20,13 @@ def create_new_user(session: Session, user: User) -> User:
     :return: Optional[User]
     """
     try:
-        user_query = session.query(User).filter(User.username == user.username).first()
-        if user_query is None:
+        existing_user = session.query(User).filter(User.username == user.username).first()
+        if existing_user is None:
             session.add(user)  # Add the user
             session.commit()  # Commit the change
             LOGGER.success(f"Created user: {user}")
         else:
-            LOGGER.warning(f"Users already exists in database: {user_query}")
+            LOGGER.warning(f"Users already exists in database: {existing_user}")
         return session.query(User).filter(User.username == user.username).first()
     except IntegrityError as e:
         LOGGER.error(e.orig)
@@ -36,31 +36,26 @@ def create_new_user(session: Session, user: User) -> User:
         raise e
 
 
-def create_post(session: Session, post: Post, admin_user: User) -> Post:
+def create_post(session: Session, post: Post) -> Post:
     """
-    Create a post authored by `admin_user`.
+    Create a post.
 
     :param session: SQLAlchemy database session.
     :type session: Session
     :param post: Blog post to be created.
     :type post: Post
-    :param admin_user: User to serve as post or comment author.
-    :type admin_user: User
 
     :return: Post
     """
     try:
-        existing_post = (
-            session.query(Post).filter(Post.author_id == admin_user.id).first()
-        )
+        existing_post = session.query(Post).filter(Post.slug == post.slug).first()
         if existing_post is None:
-            post.author_id = admin_user.id
             session.add(post)  # Add the post
             session.commit()  # Commit the change
             LOGGER.success(
-                f"Created post {post} published by user {admin_user.username}"
+                f"Created post {post} published by user {post.author.username}"
             )
-            return session.query(Post).filter(Post.author_id == admin_user.id).first()
+            return session.query(Post).filter(Post.slug == post.slug).first()
         else:
             LOGGER.warning(f"Post already exists in database: {post}")
             return existing_post
@@ -72,14 +67,12 @@ def create_post(session: Session, post: Post, admin_user: User) -> Post:
         raise e
 
 
-def create_comment(session: Session, regular_user: User, comment: Comment) -> Comment:
+def create_comment(session: Session, comment: Comment) -> Comment:
     """
     Create a comment posted by `regular_user` on `admin_user`'s post.
 
     :param session: SQLAlchemy database session.
     :type session: Session
-    :param regular_user: User to serve as comment author.
-    :type regular_user: User
     :param comment: User comment left on published post.
     :type comment: Comment
 
@@ -88,7 +81,9 @@ def create_comment(session: Session, regular_user: User, comment: Comment) -> Co
     try:
         session.add(comment)  # Add the Comment
         session.commit()  # Commit the change
-        LOGGER.success(f"Created comment {comment} posted by user {regular_user}")
+        LOGGER.success(
+            f"Created comment {comment} posted by user {comment.user.username}"
+        )
         return comment
     except IntegrityError as e:
         LOGGER.error(e.orig)