def get_postTag_by_post_id(postId):
    with sqlite3.connect("./rare.db") as conn:
        conn.row_factory = sqlite3.Row
        db_cursor = conn.cursor()
        db_cursor.execute(
            """
		SELECT
		pt.id,
		pt.post_id,
		pt.tag_id,
		t.name
		FROM post_tag pt
		JOIN tag t on t.id = pt.tag_id
		WHERE pt.post_id = ?
		""", (postId, ))

        postTags = []
        dataset = db_cursor.fetchall()

        for row in dataset:
            postTag = PostTag(row['id'], row['post_id'], row['tag_id'])
            postTags.append(postTag.__dict__)
            tag = Tag(row['tag_id'], row['name'])
            postTag.tag = tag.__dict__

    return json.dumps(postTags)
def get_single_post(id):
    with sqlite3.connect("./rare.db") as conn:
        conn.row_factory = sqlite3.Row
        db_cursor = conn.cursor()

        # Use a ? parameter to inject a variable's value
        # into the SQL statement.
        db_cursor.execute(
            """
        SELECT
            p.id,
            p.user_id,
            p.category_id,
            p.title,
            p.publication_date,
            p.image_url,
            p.content,
            p.approved
        FROM Posts p
        WHERE p.id = ?
        """, (id, ))

        # Load the single result into memory
        data = db_cursor.fetchone()

        # Create an animal instance from the current row
        post = Post(data['id'], data['user_id'], data['category_id'],
                    data['title'], data['publication_date'], data['image_url'],
                    data['content'], data['approved'])

        db_cursor.execute(
            """
                SELECT 
                    pt.id,
                    pt.tag_id,
                    pt.post_id,
                    t.id tagId,
                    t.label
                FROM PostTags pt
                JOIN Tags t
                    ON t.id = pt.tag_id
                WHERE pt.post_id = ?
                """, (id, ))

        post_tags = db_cursor.fetchall()

        postTags = []

        for row in post_tags:
            post_tag = PostTag(row['id'], row['tag_id'], row['post_id'])

            tag = Tag(row['tag_id'], row['label'])

            post_tag.tag = tag.__dict__

            postTags.append(post_tag.__dict__)

        post.postTags = postTags

    return json.dumps(post.__dict__)
Пример #3
0
def add_to_post_tags_table(object1, type1, query):
    """Add a row to the post_tags_table """

    ids = request.form.getlist(query)
    for id in ids:
        tag_or_post_object = type1.query.get(id)
        if type1 == Post:
            tag_or_post_object.post_tag.append(PostTag(post_id=int(id), tag_id=object1.id))
        else:
            tag_or_post_object.post_tag.append(PostTag(post_id=object1.id, tag_id=int(id)))
    db.session.commit()
Пример #4
0
def commit_post(id):
    title = request.form.get('title')
    content = request.form.get('content')
    post = Post.add_post(title, content, id)

    tags = Tag.get_tags()
    for tag in tags:
        if (request.form.get(tag.name, None) is not None):
            PostTag.add(post.id, tag.id)

    return redirect(f'/users/{id}')
Пример #5
0
def setup_db():
    "Function for setting up database each time we run app.py"
    # Create all tables
    db.drop_all()
    db.create_all()

    # If table isn't empty, empty it
    User.query.delete()
    Post.query.delete()
    Tag.query.delete()
    PostTag.query.delete()

    # Add users
    graham = User(first_name="Graham", last_name="Trail")
    brit = User(first_name="Brit", last_name="Juravic")

    # Add posts
    post_1 = Post(title="First Post",
                  content="This is our first post",
                  user_id=1)
    post_2 = Post(title="Second Post",
                  content="This is our second post",
                  user_id=2)

    # Add tags
    tag_1 = Tag(name="tag1")
    tag_2 = Tag(name="tag2")

    # Add posts_tags
    post_tag_1 = PostTag(post_id=1, tag_id=1)
    post_tag_2 = PostTag(post_id=2, tag_id=2)
    post_tag_3 = PostTag(post_id=1, tag_id=2)
    post_tag_4 = PostTag(post_id=2, tag_id=1)

    # Add new objects to session, so they'll persist
    db.session.add(graham)
    db.session.add(brit)
    db.session.commit()

    db.session.add(post_1)
    db.session.add(post_2)
    db.session.commit()

    db.session.add(tag_1)
    db.session.add(tag_2)
    db.session.commit()

    db.session.add(post_tag_1)
    db.session.add(post_tag_2)
    db.session.add(post_tag_3)
    db.session.add(post_tag_4)

    # Commit--otherwise, this never gets saved!
    db.session.commit()
Пример #6
0
    def post_new(user_id):
        """Submit post request on form submit to add blog to db"""

        user = User.query.get(user_id)

        # get post details from form
        title = request.form["title"]
        body = request.form["body"]

        # get tags the user checked
        tags = Tag.query.all()
        tag_ids = []
        for tag in tags:
            if request.form.get(tag.name, None):
                tag_ids.append(tag.id)

        # create post and add to db
        post = Post(title=title, body=body, user_id=user_id)
        db.session.add(post)
        db.session.commit()

        # add tags to post
        for tag_id in tag_ids:
            post_tag = PostTag(post_id=post.id, tag_id=tag_id)
            db.session.add(post_tag)
        db.session.commit()

        return redirect(f"/users/{user_id}")
Пример #7
0
def add_post_to_user(id):
    title = request.form['post-title']
    content = request.form['post-content']
    created_at = datetime.datetime.now()
    post = Post(title=title, content=content, created_at=created_at, user_id=id)
    
    add_and_commit(post)

    curr_post = Post.query.filter(Post.created_at == created_at)
    
    #Add tags
    all_tags = db.session.query(Tag.tag_name).all()
    all_tags_list = [v for v, in all_tags]
    

    for tag in all_tags_list:
        try:
            new_tag = request.form[tag]
            tag_used = Tag.query.filter(Tag.tag_name == new_tag).all()
            link_tag = PostTag(post_id=curr_post[0].id, tag_id=tag_used[0].id)
            add_and_commit(link_tag)
        except:
            pass

    return redirect(f'/user-details/{id}')
Пример #8
0
def commits_new_post(user_id):
    """pulls in client info, creates a new post in the database, displays all user posts on their details.html page"""
    user = User.query.get_or_404(user_id)
    title = request.form['title']
    content = request.form['content']
    left_blank = False
    if title == '':
        flash('Please enter a title to create a post!', 'error')
        left_blank = True
    if content == '':
        flash('Please enter content to create a post!', 'error')
        left_blank = True
    if left_blank:
        return render_template('create_new_user_post.html', user=user)
    else:
        new_post = Post(title=title, content=content, creator_id=user_id)
        db.session.add(new_post)
        db.session.commit()

        tag_ids = request.form.getlist("tag_list")
        for t_id in tag_ids:
            new_post_tag = PostTag(tag_id=t_id, post_id=new_post.id)
            db.session.add(new_post_tag)
            db.session.commit()

        return redirect(f'/users/{user_id}')
Пример #9
0
def create_post(username):
    """Create new post"""
    if session['username'] != username:
        flash("Invalid credentials", "danger")
        return redirect('/')
    form = PostForm()
    if form.validate_on_submit():
        title = form.title.data
        content = form.content.data
        rating = form.rating.data

        user = User.query.get_or_404(username)
        post = Post(title=title,
                    content=content,
                    rating=rating,
                    username=username)
        db.session.add(post)
        db.session.commit()

        tags = request.form.getlist('tag')

        for t in tags:
            tag = Tag.query.filter_by(name=t).first()
            pt = PostTag(post_id=post.id, tag_id=tag.id)
            db.session.add(pt)
            db.session.commit()

        flash('Post added', "success")
        return redirect(f"/users/{username}")
    tags = Tag.query.all()
    return render_template("new_post.html", tags=tags, form=form)
Пример #10
0
def create_post(userid):
    """Creates a new post for the specified user"""

    user = User.query.get_or_404(userid)
    title = request.form.get('title', None)
    content = request.form.get('content', None)
    tags = request.form.getlist('tags')

    # If information is somehow not provided, will show warnings to user
    missing_title = False
    missing_content = False
    if not title:
        missing_title = True
    if not content:
        missing_content = True
    if missing_title or missing_content:
        tags = Tag.query.all()
        return render_template('posts/new_post.html',
                               user=user,
                               missing_content=missing_content,
                               missing_title=missing_title,
                               tags=tags)

    new_post = Post(title=title, content=content, user_id=user.id)

    db.session.add(new_post)
    db.session.commit()

    for tag in tags:
        new_post_tag = PostTag(post_id=new_post.id, tag_id=int(tag))
        db.session.add(new_post_tag)

    db.session.commit()

    return redirect(f'/users/{userid}')
Пример #11
0
def edit_post(post_id):

    post = Post.query.get_or_404(post_id)
    tags = Tag.query.all()
    tag_ids = post.tag_ids

    if request.method == 'POST':
        title = request.form.get('title')
        content = request.form.get('content')
        tags = request.form.getlist('tags')

        tag_list = [PostTag(post_id=post_id, tag_id=tag_id) for tag_id in tags]

        post.title = title
        post.content = content
        PostTag.query.filter_by(post_id=post_id).delete()
        db.session.commit()
        post.tags = tag_list
        db.session.commit()

        return redirect(f'/posts/{post_id}')
    else:
        return render_template('/posts/edit.html',
                               post=post,
                               tags=tags,
                               tag_ids=tag_ids)
Пример #12
0
def create_post(id):

    user = User.query.get(id)
    tags = Tag.query.all()

    if request.method == 'GET':
        return render_template("postform.html", user=user, tags=tags)

    title = request.form['title']
    content = request.form['content']
    tagstrings = request.form.getlist('checkbox')

    x = datetime.now()

    new_post = Post(title=title,
                    content=content,
                    created_at=x,
                    user_id=user.id)

    db.session.add(new_post)
    db.session.commit()

    post = Post.query.filter_by(title=title).first()

    for tagstring in tagstrings:
        for tag in tags:
            if tagstring == tag.name:
                new_TagPost = PostTag(tag_id=tag.id,
                                      post_id=post.id)
                db.session.add(new_TagPost)

    db.session.commit()

    return redirect(f"/users/{id}")
Пример #13
0
def new_post_view(user_id):
    """
    GET: Display form for adding a new post.
    POST:
        Create new post and commit to db; redirect to user_detail_view if successful,
        else redirect to this page.
    """
    if request.method == 'POST':
        title = request.form.get('title')
        content = request.form.get('content')
        tag_ids = request.form.getlist('tags')

        try:
            new_post = Post(title=title, content=content, user_id=user_id)
            new_post.posttags.extend([
                PostTag(post_id=new_post.id, tag_id=tag_id)
                for tag_id in tag_ids
            ])

            db.session.add(new_post)
            db.session.commit()
            flash('Success: post created!', 'success')
        except exc.SQLAlchemyError:
            flash('Failed to create post', 'danger')
            return redirect(url_for('new_post_view', user_id=user_id))

        return redirect(url_for('user_detail_view', user_id=user_id))

    return render_template('new_post.html',
                           user_name=User.query.get_or_404(user_id).full_name,
                           tags=Tag.query.order_by(Tag.name).all())
Пример #14
0
def create_post(id):
    """ verifies and adds post to database """

    title = request.form.get("title")
    content = request.form.get("content")
    tags = request.form.getlist("tags")

    posttime = datetime.now()
    post = Post(title=title,
                content=content,
                created_at=posttime,
                creator_id=id)
    # tagsid = Tag.query.filter(tags.name != None)

    db.session.add(post)
    db.session.commit()

    import pdb
    pdb.set_trace()
    # raise
    for tag in tags:
        tagsid = Tag.query.filter(name == tag)
        posttag = PostTag(post_id=post.id, tag_id=tagsid)
        db.session.add(posttag)
        db.session.commit()

    return redirect(url_for("user_page", id=id))
Пример #15
0
def submit_add_post(user_id):
    """Show add post form"""
    action = request.form.get("add")
    tags = Tag.query.all()
    tag_list = [
        tag.id if request.form.get(f"tag_{tag.id}") else False for tag in tags
    ]
    if action == "add":

        title = request.form["title"]
        content = request.form["content"]

        new_post = Post(title=title, content=content, user_id=user_id)
        print(new_post)

        sess.add(new_post)
        sess.commit()

        for tag in tag_list:
            if tag != False:
                new_post_tag = PostTag(post_id=new_post.id, tag_id=tag)
                sess.add(new_post_tag)
                sess.commit()

        return redirect(f"/users/{user_id}")
    else:
        return redirect(f"/users/{user_id}")
Пример #16
0
def submit_edit_post(post_id):
    """Submits edit user form and redirects back to users"""
    action = request.form.get("save")
    tags = Tag.query.all()
    tag_list = [
        tag.id if request.form.get(f"tag_{tag.id}") else False for tag in tags
    ]
    if action == "save":
        edit_post = Post.query.get_or_404(post_id)
        edit_post.title = request.form["title"]
        edit_post.content = request.form["content"]
        tag_checked = [tag.id for tag in edit_post.tags]

        sess.add(edit_post)
        sess.commit()

        for tag in tag_list:
            if tag != False and tag not in tag_checked:
                new_post_tag = PostTag(post_id=post_id, tag_id=tag)
                sess.add(new_post_tag)
                sess.commit()

        return redirect(f"/posts/{post_id}")
    else:
        return redirect(f"/posts/{post_id}")
Пример #17
0
def commit_post_edit(u_id, p_id):
    """ Commits a post edit and redirects to that updated post page """

    #Retrieve form data for Post
    title = request.form['title']
    content = request.form['content']
    created_at = get_date_time()
    #Retreive form data for tags
    tags = [int(i) for i in request.form.getlist('tag')]

    #Create new Post
    post = Post.query.get(p_id)
    post.title = title
    post.content = content
    post.created_at = created_at
    db.session.add(post)
    db.session.commit()

    #Get tag values associated with that post and delete the corresponding PostTags
    for tag in post.tags:
        PostTag_to_delete = PostTag.query.filter(
            PostTag.post_id == p_id, PostTag.tag_id == tag.id).first()
        db.session.delete(PostTag_to_delete)
        db.session.commit()

    #For each tag on the new Post, create an entry in PostTag table
    for tag in tags:
        PostTag_to_check = db.session.query
        new_post_tag = PostTag(post_id=p_id, tag_id=tag)
        db.session.add(new_post_tag)
        db.session.commit()

    return redirect(f'/users/{u_id}/posts/{p_id}')
Пример #18
0
def new_tag_view():
    """
    GET: Display form for adding a new tag.
    POST:
        Create new tag and commit to db; redirect to user_detail_view if successful,
        else redirect to this page.
    """
    if request.method == 'POST':
        name = request.form.get('name')
        post_ids = request.form.getlist('posts')
        try:
            new_tag = Tag(name=name)
            new_tag.posttags.extend([
                PostTag(post_id=post_id, tag_id=new_tag.id)
                for post_id in post_ids
            ])
            db.session.add(new_tag)
            db.session.commit()
            flash('Success: tag created!', 'success')
        except exc.SQLAlchemyError:
            flash('Failed to create tag', 'danger')
            return redirect(url_for('new_tag_view'))
        return redirect(url_for('tags_view'))

    return render_template('new_tag.html',
                           posts=Post.query.order_by(Post.title).all())
Пример #19
0
    def setUp(self):
        """Clean up existing users"""
        User.query.delete()
        test_user = User(
            id=1,
            first_name='Harry',
            last_name='Potter',
            image_url=
            'https://cdn.vox-cdn.com/thumbor/7n7Oe4myr7B7nYI-mxuuO3b-QrY=/150x0:1770x1215/1200x800/filters:focal(150x0:1770x1215)/cdn.vox-cdn.com/uploads/chorus_image/image/35330556/3176173-1748009911-hp.jp_.0.jpg'
        )
        db.session.add(test_user)
        db.session.commit()

        self.test_user = test_user

        test_post = Post(title='Title',
                         content='This is the content',
                         creator_id=test_user.id)
        db.session.add(test_post)
        db.session.commit()

        self.test_post = test_post

        test_tag = Tag(name='neato cheeto!')
        db.session.add(test_tag)
        db.session.commit()

        self.test_tag = test_tag

        test_post_tag = PostTag(post_id=test_post.id, tag_id=test_tag.id)
        db.session.add(test_post_tag)
        db.session.commit()

        self.test_post_tag = test_post_tag
Пример #20
0
    def setUp(self):
        """Add sample posts users tags posttags."""

        PostTag.query.delete()
        Post.query.delete()
        User.query.delete()
        Tag.query.delete()

        u1 = User(
            first_name='Michael',
            last_name='Schienbein',
            image_url='https://files.catbox.moe/g1vsie.png')
        p1 = Post(
            title='Test Post One',
            content='This is a models unittest post',
            user=u1)
        t1 = Tag(name="Test1")

        t2 = Tag(name="Test2")

        db.session.add(u1)
        db.session.commit()
        db.session.add_all([p1, t1, t2])
        db.session.commit()

        pt = PostTag(post_id=p1.id, tag_id=t1.id)
        db.session.add(pt)
        db.session.commit()

        self.user_id = u1.id
        self.post_id = p1.id
        self.tags_id = t1.id
Пример #21
0
def create_post():
    """ Create a new post
    ---
    parameters:
      - in: "body"
        name: "body"
        description: "Create a new post"
        required: true
        schema:
          $ref: "#/definitions/CreatePostRequest"
    responses:
      400:
        description: "Invalid input"
      401:
        description: "Invalid token or API token not supplied"
    security:
      tokenauth: []
    definitions:
      CreatePostRequest:
        type: "object"
        properties:
          subject:
            type: "string"
          content:
            type: "string"
          public:
            type: "boolean"
          tags:
            type: "[string]"
    securityDefinitions:
      tokenauth:
        type: apiKey
        in: header
        name: TIL-API-TOKEN
    """

    post_data = request.json
    post = Post(subject=post_data.get('subject'),
                content=post_data.get('content'),
                author_id=flask.request.user_id,
                public=bool(post_data.get('public')))
    db.session.add(post)
    db.session.commit()

    tags_list = post_data.get('tags')
    if tags_list:
        for tag in tags_list:
            tag = tag.strip()
            t = Tag.query.filter_by(tag=tag).first()
            if not t:
                t = Tag(tag=tag)
                db.session.add(t)
                db.session.commit()
            pt = PostTag(post_id=post.id, tag_id=t.id)
            db.session.add(pt)
            db.session.commit()

    # TODO: DB error handling
    return jsonify({'post_id': post.id})
Пример #22
0
def add_post():
    """Add new post"""
    user = User.get_single_user(request.form["user"])
    title = request.form["title"]
    content = request.form["content"]
    tags = request.form.getlist("tags")

    if (title == "" or content == ""):
        flash("Missing Input: Please fill out both Title and Content")
        return redirect(f"/create_post/{user.id}")

    post = Post(title=title, content=content, user_id=user.id)
    Post.add_post(post)
    for tag in tags:
        PostTag.add_post_tag(PostTag(post_id=post.id, tag_id=tag))

    return redirect(f"/post_detail/{post.id}")
Пример #23
0
def edit_post(id):
    """Edit existing customer information in database"""
    title = request.form["title"]
    content = request.form["content"]
    tags = request.form.getlist("tags")

    if (title == "" or content == ""):
        flash("Missing Input: Please fill out both Title and Content")
        return redirect(url_for("edit_post_form", id=id))

    post = Post.get_single_post(id)
    Post.update_post(post, [title, content])
    PostTag.delete_post_tags(post.id)
    for tag in tags:
        PostTag.add_post_tag(PostTag(post_id=post.id, tag_id=tag))

    return redirect(f"/post_detail/{id}")
    def setUp(self):
        """Clear Database"""
        User.query.delete()
        Post.query.delete()
        Tag.query.delete()

        self.user = User(**USER_DATA)
        db.session.add(self.user)
        db.session.commit()

        self.post = Post(**POST_DATA, user_id=self.user.id)
        db.session.add(self.post)
        db.session.commit()

        self.tag = Tag(**TAG_DATA)
        db.session.add(self.tag)
        db.session.commit()

        PostTag.add_post_tag(PostTag(post_id=self.post.id, tag_id=self.tag.id))
Пример #25
0
def update_postag(post, tags):
    PostTag.query.filter(PostTag.post_id == post.id).delete()
    db.session.commit()
    for tag in tags:
        new_postag = PostTag(post_id=post.id, tag_id=tag.id)
        db.session.add(new_postag)
        try:
            db.session.commit()
        except Exception as error:
            msg = 'failed to update post'
            return render_template('error.html', msg=msg)
Пример #26
0
def seed():
    db.drop_all()
    db.create_all()

    user1 = User(
        first_name="ash",
        last_name='g',
        profile_image_url=
        'https://hips.hearstapps.com/hmg-prod.s3.amazonaws.com/images/dog-puppy-on-garden-royalty-free-image-1586966191.jpg?crop=1.00xw:0.669xh;0,0.190xh&resize=640:*'
    )
    user2 = User(
        first_name='tristo',
        last_name='brobo',
        profile_image_url=
        'https://thezebra.org/wp-content/uploads/2020/07/Training-Time-Aug2020-GR-with-ball-scaled.jpg'
    )

    db.session.add_all([user1, user2])
    db.session.commit()

    post1 = Post(title="I want pizza",
                 content="Pizza would be nice given I'm starving to death",
                 posted_by=2)
    post2 = Post(title="Why is the weekend so suffocatingly, brutally short?",
                 content="just wondering",
                 posted_by=1)

    db.session.add_all([post1, post2])
    db.session.commit()

    tag1 = Tag(name="food")
    tag2 = Tag(name="existential")

    db.session.add_all([tag1, tag2])
    db.session.commit()

    posttag1 = PostTag(post_id=1, tag_id=1)
    posttag2 = PostTag(post_id=2, tag_id=2)

    db.session.add_all([posttag1, posttag2])
    db.session.commit()
Пример #27
0
def create_postag(title, user_id, tags):
    post = Post.query.filter((Post.title == title)
                             & (Post.user_id == user_id)).one()
    post_id = post.id
    for tag in tags:
        new_postag = PostTag(post_id=post_id, tag_id=tag.id)
        db.session.add(new_postag)
    try:
        db.session.commit()
    except Exception as error:
        msg = 'oh my god theres an error'
        return render_template('error.html', msg=msg)
def post_new_post(user_id=None, post_id=None):
    entry = User.query.get(user_id) if user_id else Post.query.get(post_id)
    if entry == None:
        return redirect("/users")

    # Validate arguments
    args = {}
    tags = []
    for key, val in request.form.to_dict().items():
        # Tag argument
        if key[0:4] == "tag-":
            tag = Tag.query.filter(Tag.name == key[4:]).first()
            if tag == None or val != "1":
                flash(f"Unknown argument: \"{key}\"")
                return redirect(request.url)
            else:
                tags.append(tag)
        # Normal argument
        else:
            if key not in post_mapper:
                flash(f"Unknown argument: \"{key}\"")
                return redirect(request.url)
            val = val.strip()
            args[key] = None if not val else val

    # Create/edit post
    post = Post(created_at=db.func.now(),
                user_id=user_id) if post_id == None else entry
    for key, val in args.items():
        setattr(post, key, val)
    if user_id != None:
        db.session.add(post)

    # Delete tags
    for tag in post.tags:
        if tag not in tags:
            db.session.delete(
                PostTag.query.filter(PostTag.post_id == post_id,
                                     PostTag.tag_id == tag.id).first())
    # Add tags
    for tag in tags:
        db.session.add(PostTag(post_id=post.id, tag_id=tag.id))

    # Commit changes to DB
    try:
        db.session.commit()
    except:
        flash("Error: a title is required")
        return redirect(request.url)

    return redirect(
        f"/users/{user_id}" if user_id != None else f"/posts/{post_id}")
def main(sample_size, show_progress, *args, **kwargs):

    # Set up progress bar.
    if show_progress:
        progress_bar = ProgressBar(maxval=len(TAGS), widgets=[
            'Progress: ', Percentage(),
            ' ', Bar(marker=RotatingMarker()),
            ' ', ETA(),
            ' Fetched posts for ', Counter(), ' / ' + str(len(TAGS)) + ' tags.'
        ])
        progress_bar.start()

    # Fetch statistics for posts related to each tag
    for tag_count, tag in enumerate(TAGS, start=1):

        # As it turns out, we can make the selection of random posts tractable if we
        # don't do a random ordering in SQL but instead do a random selection
        # in Python.  So we start by fetching all of the post IDs for a tag,
        # make the random choice locally, and then query for the posts in this subset.
        post_id_tuples = (
            PostTag.select()
            .join(Tag, on=(PostTag.tag_id == Tag.id))
            .where(Tag.tag_name == tag)
            .select(PostTag.post_id)
            .tuples()
        )

        # We convert this from a 2D Nx1 matrix to a 1D N-length matrix by taking its
        # transpose and then getting the "first row" of the transpose.
        post_ids = np.array(post_id_tuples).T[0]
        sample_post_ids = np.random.choice(post_ids, sample_size, replace=False).tolist()

        post_records = (
            Post.select(Post.title, Post.creation_date, Post.answer_count, Post.comment_count,
                        Post.favorite_count, Post.score, Post.view_count)
            .where(Post.id << sample_post_ids)
            .dicts()
        )

        # Store which tag this record is associated with
        for record in post_records:
            record['tag_name'] = tag

        yield post_records

        if show_progress:
            progress_bar.update(tag_count)

    if show_progress:
        progress_bar.finish()

    raise StopIteration
Пример #30
0
def edit_post(post_id):
    """
        Edits post with id post_id using info user submitted in the form
        type post_id: int
        rtype: str
    """
    # get info submitted in form
    title = request.form["title"]
    content = request.form["content"]

    # verify the user entered both title and content
    if not title or not content:
        flash("Please fill out all fields", "danger")
        return redirect(f"/posts/{post_id}/edit")

    # edit post
    post = Post.query.get(post_id)
    post.title = title
    post.content = content
    db.session.add(post)
    db.session.commit()

    # update tags for post
    tags = Tag.query.all()
    post_tags = post.tags
    for tag in tags:
        # if checked and wasn't checked before, add tag to post
        if request.form.get(tag.name, None):
            tag_added = True
            for post_tag in post_tags:
                # if post already had tag, tag was not added
                if tag.id == post_tag.id:
                    tag_added = False
            if tag_added:
                post_tag = PostTag(post_id=post.id, tag_id=tag.id)
                db.session.add(post_tag)
        # if not checked and was before, remove tag from post
        else:
            tag_removed = False
            for post_tag in post_tags:
                # if post used to have tag, tag was removed
                if tag.id == post_tag.id:
                    tag_removed = True
            if tag_removed:
                post_tag = PostTag.query.filter_by(post_id=post.id, tag_id=tag.id).one()
                db.session.delete(post_tag)
    db.session.commit()

    flash("Post has been successfully updated", "success")
    return redirect(f"/posts/{post_id}")
Пример #31
0
    def test_find_snippet_with_tags(self):

        # These two posts are equivalent, except that only is tagged with a tag that we
        # will use for filtering in the test.
        post1 = create_post(body=self._make_post_body('\n'.join([
            'import re',
            'characters = re.findall(r"\w", "foo")',
            'for c in characters:',
            '    print c',
        ])))
        post2 = create_post(body=self._make_post_body('\n'.join([
            'import re',
            'characters = re.findall(r"\w", "foo")',
            'for c in characters:',
            '    print c',
        ])))
        tag1 = create_tag(tag_name='javascript')
        tag2 = create_tag(tag_name='python')
        PostTag.create(post_id=post1.id, tag_id=tag1.id)
        PostTag.create(post_id=post2.id, tag_id=tag2.id)

        self._extract(['re.findall'], tags=['python'])
        self.assertEqual(PostSnippet.select().count(), 1)
        self.assertEqual(PostSnippet.select().first().post, post2)
 def _create_post(self, body, tag_name='node.js'):
     post = create_post(body=self._make_post_body(body))
     tag = create_tag(tag_name=tag_name)
     PostTag.create(post_id=post.id, tag_id=tag.id)
     return post