Django Mezzanine model creating two objects

Question

I am using the Mezzanine CMS for Django to create a blog, and I wanted a separate page for a list of my personal projects. What I did was pretty much copy the BlogPost model from Mezzanine and called it Projects. Everything I needed was in the BlogPost model, so I decided against creating my own. I assumed copying over the code for BlogPost would work, and it kind of did.

My issue lies when I go to the admin page to create a new project in the projects panel. When I create the new project, it is successfully created. So, I see it in the projects panel. When I go to my blog posts panel, I also see the project I just created. Every time I make a blog post, it does not show up in the projects panel. I need to create a project and have it not show up in the blog posts panel. Did I mess up by basically inheriting the BlogPost model for my Projects model? How can I create a project without it creating a blog post?

Here is my app/models.py:

from django.db import models
from mezzanine.blog.models import BlogPost, BlogCategory
# Create your models here.

class Projects(BlogPost):
    github_link = models.CharField(max_length=255, blank=True, null=True)

class ProjectsCategory(BlogCategory):
    pass

My views are also identical to Mezzanines views for the BlogPost model.
app/views.py:

from django.shortcuts import render, redirect
from calendar import month_name

from django.contrib.auth import get_user_model
from django.http import Http404
from django.shortcuts import get_object_or_404
from django.template.response import TemplateResponse
from django.utils.translation import ugettext_lazy as _

#from mezzanine.blog.models import BlogPost, BlogCategory
from theme.models import Projects, ProjectsCategory
from mezzanine.blog.feeds import PostsRSS, PostsAtom
from mezzanine.conf import settings
from mezzanine.generic.models import Keyword
from mezzanine.utils.views import paginate

User = get_user_model()
# Create your views here.

def blog_redirect(request):
    return redirect('/', permanent=True)

def project_list(request, tag=None, year=None, month=None, username=None,
                   category=None, template="projects/projects.html",
                   extra_context=None):
    """
    Display a list of blog posts that are filtered by tag, year, month,
    author or category. Custom templates are checked for using the name
    ``blog/blog_post_list_XXX.html`` where ``XXX`` is either the
    category slug or author's username if given.
    """
    templates = []
    projects = Projects.objects.published(for_user=request.user)
    if tag is not None:
        tag = get_object_or_404(Keyword, slug=tag)
        projects = projects.filter(keywords__keyword=tag)
    if year is not None:
        projects = projects.filter(publish_date__year=year)
        if month is not None:
            projects = projects.filter(publish_date__month=month)
            try:
                month = _(month_name[int(month)])
            except IndexError:
                raise Http404()
    if category is not None:
        category = get_object_or_404(ProjectsCategory, slug=category)
        projects = projects.filter(categories=category)
        templates.append(u"projects/projects_%s.html" %
                          str(category.slug))
    author = None
    if username is not None:
        author = get_object_or_404(User, username=username)
        projects = projects.filter(user=author)
        templates.append(u"projects/projects_%s.html" % username)

    prefetch = ("categories", "keywords__keyword")
    projects = projects.select_related("user").prefetch_related(*prefetch)
    projects = paginate(projects, request.GET.get("page", 1),
                          settings.BLOG_POST_PER_PAGE,
                          settings.MAX_PAGING_LINKS)
    context = {"projects": projects, "year": year, "month": month,
               "tag": tag, "category": category, "author": author}
    context.update(extra_context or {})
    templates.append(template)
    return TemplateResponse(request, templates, context)


def project_detail(request, slug, year=None, month=None, day=None,
                     template="projects/projects_detail.html",
                     extra_context=None):
    """. Custom templates are checked for using the name
    ``blog/blog_post_detail_XXX.html`` where ``XXX`` is the blog
    posts's slug.
    """
    projects = Projects.objects.published(
                                     for_user=request.user).select_related()
    project = get_object_or_404(projects, slug=slug)
    related_posts = project.related_posts.published(for_user=request.user)
    context = {"project": project, "editable_obj": project,
               "related_posts": related_posts}
    context.update(extra_context or {})
    templates = [u"projects/projects_detail_%s.html" % str(slug), template]
    return TemplateResponse(request, templates, context)

Here is my app/admin.py:

from copy import deepcopy
from django.utils.translation import ugettext_lazy as _
from django.contrib import admin
from mezzanine.blog.admin import BlogPostAdmin
from mezzanine.blog.models import BlogPost
from mezzanine.pages.admin import PageAdmin
from mezzanine.pages.models import RichTextPage
from mezzanine.core.admin import (DisplayableAdmin, OwnableAdmin,
                                  BaseTranslationModelAdmin)
from mezzanine.twitter.admin import TweetableAdminMixin
from mezzanine.conf import settings
from theme.models import Projects

blog_fieldsets = deepcopy(BlogPostAdmin.fieldsets)
blog_fieldsets[0][1]["fields"].insert(-2, "retina")


pages_fieldsets = deepcopy(PageAdmin.fieldsets)
pages_fieldsets[0][1]["fields"].insert(-2, "page_image")
pages_fieldsets[0][1]["fields"].insert(-3, "content")


project_fieldsets = deepcopy(DisplayableAdmin.fieldsets)
project_fieldsets[0][1]["fields"].insert(1, "categories")
project_fieldsets[0][1]["fields"].extend(["content", "allow_comments"])
project_list_display = ["title", "user", "status", "admin_link"]
if settings.BLOG_USE_FEATURED_IMAGE:
    project_fieldsets[0][1]["fields"].insert(-2, "featured_image")
    project_list_display.insert(0, "admin_thumb")
project_fieldsets = list(project_fieldsets)
project_fieldsets.insert(1, (_("Other posts"), {
    "classes": ("collapse-closed",),
    "fields": ("related_posts",)}))
project_list_filter = deepcopy(DisplayableAdmin.list_filter) + ("categories",)



class MyBlogPostAdmin(BlogPostAdmin):
    fieldsets = blog_fieldsets

class MyPageAdmin(PageAdmin):
    fieldsets = pages_fieldsets


class ProjectsAdmin(TweetableAdminMixin, DisplayableAdmin, OwnableAdmin):
    fieldsets = project_fieldsets
    list_display = project_list_display
    list_filter = project_list_filter
    filter_horizontal = ("categories", "related_posts",)

    def save_form(self, request, form, change):
        """
        Super class ordering is important here - user must get saved first.
        """
        OwnableAdmin.save_form(self, request, form, change)
        return DisplayableAdmin.save_form(self, request, form, change)

admin.site.unregister(Projects)
admin.site.unregister(BlogPost)
admin.site.unregister(RichTextPage)
admin.site.register(Projects, ProjectsAdmin)
admin.site.register(BlogPost, MyBlogPostAdmin)
admin.site.register(RichTextPage, MyPageAdmin)