BigMigration: Restoring functionality

14 files changed, 370 insertions, 143 deletions

diff --git a/askbot/auth.py b/askbot/auth.py
index 5227e678..5c0f7bd9 100644
--- a/askbot/auth.py
+++ b/askbot/auth.py
@@ -25,17 +25,14 @@ def onFlaggedItem(post, user, timestamp=None):
     post.offensive_flag_count = post.offensive_flag_count + 1
     post.save()
 
-    if post.post_type == 'comment':#todo: fix this
-        flagged_user = post.user
-    else:
-        flagged_user = post.author
+    flagged_user = post.author
 
     flagged_user.receive_reputation(
         askbot_settings.REP_LOSS_FOR_RECEIVING_FLAG
     )
     flagged_user.save()
 
-    question = post.get_origin_post()
+    question = post.thread._question_post()
 
     reputation = Repute(
                     user=flagged_user,
@@ -111,17 +108,14 @@ def onUnFlaggedItem(post, user, timestamp=None):
     post.offensive_flag_count = post.offensive_flag_count - 1
     post.save()
 
-    if post.post_type == 'comment':#todo: fix this
-        flagged_user = post.user
-    else:
-        flagged_user = post.author
+    flagged_user = post.author
 
     flagged_user.receive_reputation(
         - askbot_settings.REP_LOSS_FOR_RECEIVING_FLAG
     )
     flagged_user.save()
 
-    question = post.get_origin_post()
+    question = post.thread._question_post()
 
     reputation = Repute(
                     user=flagged_user,
@@ -189,7 +183,9 @@ def onUnFlaggedItem(post, user, timestamp=None):
 
 @transaction.commit_on_success
 def onAnswerAccept(answer, user, timestamp=None):
-    answer.question.thread.set_accepted_answer(answer=answer, timestamp=timestamp)
+    answer.thread.set_accepted_answer(answer=answer, timestamp=timestamp)
+    question = answer.thread._question_post()
+
     if answer.author != user:
         answer.author.receive_reputation(
             askbot_settings.REP_GAIN_FOR_RECEIVING_ANSWER_ACCEPTANCE
@@ -197,7 +193,7 @@ def onAnswerAccept(answer, user, timestamp=None):
         answer.author.save()
         reputation = Repute(user=answer.author,
                    positive=askbot_settings.REP_GAIN_FOR_RECEIVING_ANSWER_ACCEPTANCE,
-                   question=answer.question,
+                   question=question,
                    reputed_at=timestamp,
                    reputation_type=2,
                    reputation=answer.author.reputation)
@@ -207,7 +203,7 @@ def onAnswerAccept(answer, user, timestamp=None):
     user.save()
     reputation = Repute(user=user,
                positive=askbot_settings.REP_GAIN_FOR_ACCEPTING_ANSWER,
-               question=answer.question,
+               question=question,
                reputed_at=timestamp,
                reputation_type=3,
                reputation=user.reputation)
@@ -217,17 +213,20 @@ def onAnswerAccept(answer, user, timestamp=None):
 def onAnswerAcceptCanceled(answer, user, timestamp=None):
     if timestamp is None:
         timestamp = datetime.datetime.now()
-    answer.question.thread.set_accepted_answer(answer=None, timestamp=None)
+    answer.thread.set_accepted_answer(answer=None, timestamp=None)
 
     answer.author.receive_reputation(
         askbot_settings.REP_LOSS_FOR_RECEIVING_CANCELATION_OF_ANSWER_ACCEPTANCE
     )
     answer.author.save()
+
+    question = answer.thread._question_post()
+
     reputation = Repute(
         user=answer.author,
         negative=\
          askbot_settings.REP_LOSS_FOR_RECEIVING_CANCELATION_OF_ANSWER_ACCEPTANCE,
-        question=answer.question,
+        question=question,
         reputed_at=timestamp,
         reputation_type=-2,
         reputation=answer.author.reputation
@@ -240,7 +239,7 @@ def onAnswerAcceptCanceled(answer, user, timestamp=None):
     user.save()
     reputation = Repute(user=user,
                negative=askbot_settings.REP_LOSS_FOR_CANCELING_ANSWER_ACCEPTANCE,
-               question=answer.question,
+               question=question,
                reputed_at=timestamp,
                reputation_type=-1,
                reputation=user.reputation)
@@ -270,9 +269,7 @@ def onUpVoted(vote, post, user, timestamp=None):
             )
             author.save()
 
-            question = post
-            if isinstance(post, Answer):
-                question = post.question
+            question = post.thread._question_post() # TODO: this is suboptimal if post is already a question
 
             reputation = Repute(user=author,
                        positive=askbot_settings.REP_GAIN_FOR_RECEIVING_UPVOTE,
@@ -307,9 +304,7 @@ def onUpVotedCanceled(vote, post, user, timestamp=None):
         )
         author.save()
 
-        question = post
-        if isinstance(post, Answer):
-            question = post.question
+        question = post.thread._question_post() # TODO: this is suboptimal if post is already a question
 
         reputation = Repute(
             user=author,
@@ -336,9 +331,7 @@ def onDownVoted(vote, post, user, timestamp=None):
         author.receive_reputation(askbot_settings.REP_LOSS_FOR_DOWNVOTING)
         author.save()
 
-        question = post
-        if isinstance(post, Answer):
-            question = post.question
+        question = post.thread._question_post() # TODO: this is suboptimal if post is already a question
 
         reputation = Repute(user=author,
                    negative=askbot_settings.REP_LOSS_FOR_DOWNVOTING,
@@ -380,9 +373,7 @@ def onDownVotedCanceled(vote, post, user, timestamp=None):
         )
         author.save()
 
-        question = post
-        if isinstance(post, Answer):
-            question = post.question
+        question = post.thread._question_post() # TODO: this is suboptimal if post is already a question
 
         reputation = Repute(user=author,
                 positive=\
diff --git a/askbot/forms.py b/askbot/forms.py
index a0e5540a..f6c8a8bb 100644
--- a/askbot/forms.py
+++ b/askbot/forms.py
@@ -754,7 +754,7 @@ class RevisionForm(forms.Form):
 
     def __init__(self, post, latest_revision, *args, **kwargs):
         super(RevisionForm, self).__init__(*args, **kwargs)
-        revisions = post.revisions().values_list(
+        revisions = post.revisions.values_list(
             'revision', 'author__username', 'revised_at', 'summary')
         date_format = '%c'
         self.fields['revision'].choices = [
diff --git a/askbot/migrations/0104_auto__del_field_repute_question_post__add_field_repute_question.py b/askbot/migrations/0104_auto__del_field_repute_question_post__add_field_repute_question.py
new file mode 100644
index 00000000..3a1a87a1
--- /dev/null
+++ b/askbot/migrations/0104_auto__del_field_repute_question_post__add_field_repute_question.py
@@ -0,0 +1,267 @@
+# encoding: utf-8
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        db.rename_column(u'repute', 'question_post_id', 'question_id')
+
+
+    def backwards(self, orm):
+        db.rename_column(u'repute', 'question_id', 'question_post_id')
+
+
+    models = {
+        'askbot.activity': {
+            'Meta': {'object_name': 'Activity', 'db_table': "u'activity'"},
+            'active_at': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'activity_type': ('django.db.models.fields.SmallIntegerField', [], {}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_auditted': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'object_id': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'question': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['askbot.Post']", 'null': 'True'}),
+            'receiving_users': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'received_activity'", 'symmetrical': 'False', 'to': "orm['auth.User']"}),
+            'recipients': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'incoming_activity'", 'symmetrical': 'False', 'through': "orm['askbot.ActivityAuditStatus']", 'to': "orm['auth.User']"}),
+            'summary': ('django.db.models.fields.TextField', [], {'default': "''"}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        },
+        'askbot.activityauditstatus': {
+            'Meta': {'unique_together': "(('user', 'activity'),)", 'object_name': 'ActivityAuditStatus'},
+            'activity': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['askbot.Activity']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'status': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        },
+        'askbot.anonymousanswer': {
+            'Meta': {'object_name': 'AnonymousAnswer'},
+            'added_at': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'author': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip_addr': ('django.db.models.fields.IPAddressField', [], {'max_length': '15'}),
+            'question_post': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'anonymous_answers'", 'to': "orm['askbot.Post']"}),
+            'session_key': ('django.db.models.fields.CharField', [], {'max_length': '40'}),
+            'summary': ('django.db.models.fields.CharField', [], {'max_length': '180'}),
+            'text': ('django.db.models.fields.TextField', [], {}),
+            'wiki': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
+        },
+        'askbot.anonymousquestion': {
+            'Meta': {'object_name': 'AnonymousQuestion'},
+            'added_at': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'author': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip_addr': ('django.db.models.fields.IPAddressField', [], {'max_length': '15'}),
+            'is_anonymous': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'session_key': ('django.db.models.fields.CharField', [], {'max_length': '40'}),
+            'summary': ('django.db.models.fields.CharField', [], {'max_length': '180'}),
+            'tagnames': ('django.db.models.fields.CharField', [], {'max_length': '125'}),
+            'text': ('django.db.models.fields.TextField', [], {}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '300'}),
+            'wiki': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
+        },
+        'askbot.award': {
+            'Meta': {'object_name': 'Award', 'db_table': "u'award'"},
+            'awarded_at': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'badge': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'award_badge'", 'to': "orm['askbot.BadgeData']"}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'notified': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'object_id': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'award_user'", 'to': "orm['auth.User']"})
+        },
+        'askbot.badgedata': {
+            'Meta': {'ordering': "('slug',)", 'object_name': 'BadgeData'},
+            'awarded_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
+            'awarded_to': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'badges'", 'symmetrical': 'False', 'through': "orm['askbot.Award']", 'to': "orm['auth.User']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '50', 'db_index': 'True'})
+        },
+        'askbot.emailfeedsetting': {
+            'Meta': {'object_name': 'EmailFeedSetting'},
+            'added_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
+            'feed_type': ('django.db.models.fields.CharField', [], {'max_length': '16'}),
+            'frequency': ('django.db.models.fields.CharField', [], {'default': "'n'", 'max_length': '8'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'reported_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}),
+            'subscriber': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'notification_subscriptions'", 'to': "orm['auth.User']"})
+        },
+        'askbot.favoritequestion': {
+            'Meta': {'object_name': 'FavoriteQuestion', 'db_table': "u'favorite_question'"},
+            'added_at': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'thread': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['askbot.Thread']"}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'user_favorite_questions'", 'to': "orm['auth.User']"})
+        },
+        'askbot.markedtag': {
+            'Meta': {'object_name': 'MarkedTag'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'reason': ('django.db.models.fields.CharField', [], {'max_length': '16'}),
+            'tag': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'user_selections'", 'to': "orm['askbot.Tag']"}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'tag_selections'", 'to': "orm['auth.User']"})
+        },
+        'askbot.post': {
+            'Meta': {'object_name': 'Post'},
+            'added_at': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'author': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'posts'", 'to': "orm['auth.User']"}),
+            'comment_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
+            'deleted': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'deleted_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'deleted_by': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'deleted_posts'", 'null': 'True', 'to': "orm['auth.User']"}),
+            'html': ('django.db.models.fields.TextField', [], {'null': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_anonymous': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_edited_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'last_edited_by': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'last_edited_posts'", 'null': 'True', 'to': "orm['auth.User']"}),
+            'locked': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'locked_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'locked_by': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'locked_posts'", 'null': 'True', 'to': "orm['auth.User']"}),
+            'offensive_flag_count': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'parent': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'comments'", 'null': 'True', 'to': "orm['askbot.Post']"}),
+            'post_type': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'score': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'summary': ('django.db.models.fields.CharField', [], {'max_length': '180'}),
+            'text': ('django.db.models.fields.TextField', [], {'null': 'True'}),
+            'thread': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'posts'", 'to': "orm['askbot.Thread']"}),
+            'vote_down_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'vote_up_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'wiki': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'wikified_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'})
+        },
+        'askbot.postrevision': {
+            'Meta': {'ordering': "('-revision',)", 'unique_together': "(('post', 'revision'),)", 'object_name': 'PostRevision'},
+            'author': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'postrevisions'", 'to': "orm['auth.User']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_anonymous': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'post': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'revisions'", 'null': 'True', 'to': "orm['askbot.Post']"}),
+            'revised_at': ('django.db.models.fields.DateTimeField', [], {}),
+            'revision': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'revision_type': ('django.db.models.fields.SmallIntegerField', [], {}),
+            'summary': ('django.db.models.fields.CharField', [], {'max_length': '300', 'blank': 'True'}),
+            'tagnames': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '125', 'blank': 'True'}),
+            'text': ('django.db.models.fields.TextField', [], {}),
+            'title': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '300', 'blank': 'True'})
+        },
+        'askbot.questionview': {
+            'Meta': {'object_name': 'QuestionView'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'question': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'viewed'", 'to': "orm['askbot.Post']"}),
+            'when': ('django.db.models.fields.DateTimeField', [], {}),
+            'who': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'question_views'", 'to': "orm['auth.User']"})
+        },
+        'askbot.repute': {
+            'Meta': {'object_name': 'Repute', 'db_table': "u'repute'"},
+            'comment': ('django.db.models.fields.CharField', [], {'max_length': '128', 'null': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'negative': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'positive': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'question': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['askbot.Post']", 'null': 'True', 'blank': 'True'}),
+            'reputation': ('django.db.models.fields.IntegerField', [], {'default': '1'}),
+            'reputation_type': ('django.db.models.fields.SmallIntegerField', [], {}),
+            'reputed_at': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        },
+        'askbot.tag': {
+            'Meta': {'ordering': "('-used_count', 'name')", 'object_name': 'Tag', 'db_table': "u'tag'"},
+            'created_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'created_tags'", 'to': "orm['auth.User']"}),
+            'deleted': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'deleted_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'deleted_by': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'deleted_tags'", 'null': 'True', 'to': "orm['auth.User']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
+            'used_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'})
+        },
+        'askbot.thread': {
+            'Meta': {'object_name': 'Thread'},
+            'accepted_answer': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'+'", 'null': 'True', 'to': "orm['askbot.Post']"}),
+            'answer_accepted_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'answer_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
+            'close_reason': ('django.db.models.fields.SmallIntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'closed': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'closed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'closed_by': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'}),
+            'favorited_by': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'unused_favorite_threads'", 'symmetrical': 'False', 'through': "orm['askbot.FavoriteQuestion']", 'to': "orm['auth.User']"}),
+            'favourite_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
+            'followed_by': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'followed_threads'", 'symmetrical': 'False', 'to': "orm['auth.User']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'last_activity_at': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_activity_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'unused_last_active_in_threads'", 'to': "orm['auth.User']"}),
+            'tagnames': ('django.db.models.fields.CharField', [], {'max_length': '125'}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'threads'", 'symmetrical': 'False', 'to': "orm['askbot.Tag']"}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '300'}),
+            'view_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'})
+        },
+        'askbot.vote': {
+            'Meta': {'unique_together': "(('user', 'voted_post'),)", 'object_name': 'Vote', 'db_table': "u'vote'"},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'votes'", 'to': "orm['auth.User']"}),
+            'vote': ('django.db.models.fields.SmallIntegerField', [], {}),
+            'voted_at': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'voted_post': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'votes'", 'to': "orm['askbot.Post']"})
+        },
+        'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        'auth.permission': {
+            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'auth.user': {
+            'Meta': {'object_name': 'User'},
+            'about': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'avatar_type': ('django.db.models.fields.CharField', [], {'default': "'n'", 'max_length': '1'}),
+            'bronze': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'consecutive_days_visit_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'country': ('django_countries.fields.CountryField', [], {'max_length': '2', 'blank': 'True'}),
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'date_of_birth': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
+            'display_tag_filter_strategy': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'email_isvalid': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'email_key': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True'}),
+            'email_tag_filter_strategy': ('django.db.models.fields.SmallIntegerField', [], {'default': '1'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'gold': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'gravatar': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ignored_tags': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'interesting_tags': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'last_seen': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'location': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
+            'new_response_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'questions_per_page': ('django.db.models.fields.SmallIntegerField', [], {'default': '10'}),
+            'real_name': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
+            'reputation': ('django.db.models.fields.PositiveIntegerField', [], {'default': '1'}),
+            'seen_response_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'show_country': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'silver': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
+            'status': ('django.db.models.fields.CharField', [], {'default': "'w'", 'max_length': '2'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'}),
+            'website': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'})
+        },
+        'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        }
+    }
+
+    complete_apps = ['askbot']
diff --git a/askbot/models/__init__.py b/askbot/models/__init__.py
index a96a8251..0f907fcf 100644
--- a/askbot/models/__init__.py
+++ b/askbot/models/__init__.py
@@ -177,19 +177,12 @@ def user_get_old_vote_for_post(self, post):
     raises assertion_error is number of old votes is > 1
     which is illegal
     """
-    post_content_type = ContentType.objects.get_for_model(post)
-    old_votes = Vote.objects.filter(
-                                user = self,
-                                content_type = post_content_type,
-                                object_id = post.id
-                            )
-    if len(old_votes) == 0:
+    try:
+        return Vote.objects.get(user=self, voted_post=post)
+    except Vote.DoesNotExist:
         return None
-    else:
-        assert(len(old_votes) == 1)
-
-    return old_votes[0]
-
+    except Vote.MultipleObjectsReturned:
+        raise AssertionError
 
 def user_has_affinity_to_question(self, question = None, affinity_type = None):
     """returns True if number of tag overlap of the user tag
@@ -322,7 +315,7 @@ def user_assert_can_unaccept_best_answer(self, answer = None):
         error_message = blocked_error_message
     elif self.is_suspended():
         error_message = suspended_error_message
-    elif self == answer.question.get_owner():
+    elif self == answer.thread._question_post().get_owner():
         if self == answer.get_owner():
             if not self.is_administrator():
                 #check rep
@@ -379,13 +372,7 @@ def user_assert_can_vote_for_post(
     :param:direction can be 'up' or 'down'
     :param:post can be instance of question or answer
     """
-
-    #todo: after unifying models this if else will go away
-    if isinstance(post, Comment):
-        post_author = post.user
-    else:
-        post_author = post.author
-    if self == post_author:
+    if self == post.author:
         raise django_exceptions.PermissionDenied(_('cannot vote for own posts'))
 
     blocked_error_message = _(
@@ -1087,7 +1074,7 @@ def user_accept_best_answer(
     if answer.accepted() == True:
         return
 
-    prev_accepted_answer = answer.question.thread.accepted_answer
+    prev_accepted_answer = answer.thread.accepted_answer
     if prev_accepted_answer:
         auth.onAnswerAcceptCanceled(prev_accepted_answer, self)
 
@@ -1875,15 +1862,10 @@ def _process_vote(user, post, timestamp=None, cancel=False, vote_type=None):
     """"private" wrapper function that applies post upvotes/downvotes
     and cancelations
     """
-    post_type = ContentType.objects.get_for_model(post)
     #get or create the vote object
     #return with noop in some situations
     try:
-        vote = Vote.objects.get(
-                    user = user,
-                    content_type = post_type,
-                    object_id = post.id,
-                )
+        vote = Vote.objects.get(user = user, voted_post=post)
     except Vote.DoesNotExist:
         vote = None
     if cancel:
@@ -1901,7 +1883,7 @@ def _process_vote(user, post, timestamp=None, cancel=False, vote_type=None):
         if vote == None:
             vote = Vote(
                     user = user,
-                    content_object = post,
+                    voted_post=post,
                     vote = vote_type,
                     voted_at = timestamp,
                 )
diff --git a/askbot/models/badges.py b/askbot/models/badges.py
index df96efdc..b909b7e1 100644
--- a/askbot/models/badges.py
+++ b/askbot/models/badges.py
@@ -25,6 +25,7 @@ from django.dispatch import Signal
 from askbot.models.repute import BadgeData, Award
 from askbot.models.user import Activity
 from askbot.models.question import FavoriteQuestion as Fave#name collision
+from askbot.models.post import Post
 from askbot import const
 from askbot.conf import settings as askbot_settings
 from askbot.utils.decorators import auto_now_timestamp
@@ -264,7 +265,7 @@ class SelfLearner(Badge):
             return False
 
         min_upvotes = askbot_settings.SELF_LEARNER_BADGE_MIN_UPVOTES
-        question = context_object.question
+        question = context_object.thread._question_post()
         answer = context_object
 
         if question.author == answer.author and answer.score >= min_upvotes:
@@ -460,7 +461,7 @@ class Scholar(Badge):
         if context_object.post_type != 'answer':
             return False
         answer = context_object
-        if answer.question.author != actor:
+        if answer.thread._question_post().author != actor:
             return False
         return self.award(actor, context_object, timestamp)
 
@@ -532,7 +533,7 @@ class Necromancer(Badge):
         if context_object.post_type != 'answer':
             return False
         answer = context_object
-        question = answer.question
+        question = answer.thread._question_post()
         delta = datetime.timedelta(askbot_settings.NECROMANCER_BADGE_MIN_DELAY)
         min_score = askbot_settings.NECROMANCER_BADGE_MIN_UPVOTES
         if answer.added_at - question.added_at >= delta \
@@ -738,7 +739,7 @@ class Commentator(Badge):
 
     def consider_award(self, actor = None,
             context_object = None, timestamp = None):
-        num_comments = Comment.objects.filter(user = actor).count()
+        num_comments = Post.objects.get_comments().filter(author=actor).count()
         if num_comments >= askbot_settings.COMMENTATOR_BADGE_MIN_COMMENTS:
             return self.award(actor, context_object, timestamp)
         return False
diff --git a/askbot/models/content.py b/askbot/models/content.py
index 871e85cc..ff7af260 100644
--- a/askbot/models/content.py
+++ b/askbot/models/content.py
@@ -152,13 +152,15 @@ class Content(models.Model):
         if None in (comment ,user):
             raise Exception('arguments comment and user are required')
 
-        #Comment = models.get_model('askbot','Comment')#todo: forum hardcoded
-        comment = Comment(
-                            content_object=self, 
-                            comment=comment, 
-                            user=user, 
-                            added_at=added_at
-                        )
+        from askbot.models import Post
+        comment = Post(
+            post_type='comment',
+            thread=self.thread,
+            parent=self,
+            text=comment,
+            author=user,
+            added_at=added_at
+        )
         comment.parse_and_save(author = user)
         self.comment_count = self.comment_count + 1
         self.save()
@@ -468,7 +470,7 @@ class Content(models.Model):
 
     def get_origin_post(self):
         if self.is_answer():
-            return self.question
+            return self.thread._question_post()
         elif self.is_question():
             return self
         raise NotImplementedError
@@ -599,7 +601,7 @@ class Content(models.Model):
     def _answer__assert_is_visible_to(self, user):
         """raises QuestionHidden or AnswerHidden"""
         try:
-            self.question.assert_is_visible_to(user)
+            self.thread._question_post().assert_is_visible_to(user)
         except exceptions.QuestionHidden:
             message = _(
                         'Sorry, the answer you are looking for is '
@@ -678,7 +680,7 @@ class Content(models.Model):
 
         self.parse_and_save(author = edited_by)
 
-        self.question.thread.set_last_activity(last_activity_at=edited_at, last_activity_by=edited_by)
+        self.thread.set_last_activity(last_activity_at=edited_at, last_activity_by=edited_by)
 
     def _question__apply_edit(self, edited_at=None, edited_by=None, title=None,\
                     text=None, comment=None, tags=None, wiki=False, \
@@ -749,7 +751,7 @@ class Content(models.Model):
                 comment = 'No.%s Revision' % rev_no
         from askbot.models.post import PostRevision
         return PostRevision.objects.create_answer_revision(
-                                  answer=self,
+                                  post=self,
                                   author=author,
                                   revised_at=revised_at,
                                   text=text,
@@ -776,7 +778,7 @@ class Content(models.Model):
 
         from askbot.models.post import PostRevision
         return PostRevision.objects.create_question_revision(
-            question   = self,
+            post = self,
             revision   = rev_no,
             title      = self.thread.title,
             author     = author,
diff --git a/askbot/models/meta.py b/askbot/models/meta.py
index e39fece8..27d40c22 100644
--- a/askbot/models/meta.py
+++ b/askbot/models/meta.py
@@ -76,15 +76,14 @@ class Vote(models.Model):
         """
         #importing locally because of circular dependency
         from askbot import auth
-        score_before = self.content_object.score
+        score_before = self.voted_post.score
         if self.vote > 0:
             # cancel upvote
-            auth.onUpVotedCanceled(self, self.content_object, self.user)
-
+            auth.onUpVotedCanceled(self, self.voted_post, self.user)
         else:
             # cancel downvote
-            auth.onDownVotedCanceled(self, self.content_object, self.user)
-        score_after = self.content_object.score
+            auth.onDownVotedCanceled(self, self.voted_post, self.user)
+        score_after = self.voted_post.score
 
         return score_after - score_before
 
diff --git a/askbot/models/post.py b/askbot/models/post.py
index 26de39dc..1fe4673c 100644
--- a/askbot/models/post.py
+++ b/askbot/models/post.py
@@ -14,9 +14,13 @@ class PostManager(models.Manager):
     def get_answers(self):
         return self.filter(post_type='answer')
 
+    def get_comments(self):
+        return self.filter(post_type='comment')
+
     def create_new_answer(self, thread, author, added_at, text, wiki=False, email_notify=False):
         # TODO: Some of this code will go to Post.objects.create_new
         answer = Post(
+            post_type='answer',
             thread=thread,
             author=author,
             added_at=added_at,
@@ -58,9 +62,6 @@ class Post(content.Content):
 
     objects = PostManager()
 
-    question = property(fget=lambda self: self.thread._question_post()) # to simulate Answer model
-    question_id = property(fget=lambda self: self.thread._question_post().id) # to simulate Answer model
-
     class Meta:
         app_label = 'askbot'
         db_table = 'askbot_post'
@@ -89,7 +90,7 @@ class Post(content.Content):
     def delete(self, *args, **kwargs):
         # WARNING: This is not called for batch deletions so watch out!
         # TODO: Restore specialized Comment.delete() functionality!
-        self.delete(*args, **kwargs)
+        super(Post, self).delete(*args, **kwargs)
 
     def is_answer_accepted(self):
         if not self.is_answer():
@@ -98,7 +99,7 @@ class Post(content.Content):
 
     def accepted(self):
         if self.is_answer():
-            return self.question.thread.accepted_answer == self
+            return self.thread.accepted_answer == self
         raise NotImplementedError
 
     def get_page_number(self, answer_posts):
@@ -121,16 +122,13 @@ class Post(content.Content):
             order_number += 1
         return int(order_number/const.ANSWERS_PAGE_SIZE) + 1
 
-    def revisions(self):
-        return self.revisions.all()
-
     def get_latest_revision(self):
-        return self.revisions().order_by('-revised_at')[0]
+        return self.revisions.order_by('-revised_at')[0]
+
+    def is_upvoted_by(self, user):
+        from askbot.models.meta import Vote
+        return Vote.objects.filter(user=user, voted_post=self, vote=Vote.VOTE_UP).exists()
 
-    def apply_edit(self, *kargs, **kwargs):
-        if self.post_type not in ('question', 'answer'):
-            raise NotImplementedError
-        return post.apply_edit(*kargs, **kwargs)
 
 
 class PostRevisionManager(models.Manager):
@@ -168,7 +166,7 @@ class PostRevision(models.Model):
 
     post = models.ForeignKey('askbot.Post', related_name='revisions', null=True, blank=True)
 
-    revision_type = models.SmallIntegerField(choices=REVISION_TYPE_CHOICES)
+    revision_type = models.SmallIntegerField(choices=REVISION_TYPE_CHOICES) # TODO: remove as we have Post now
 
     revision   = models.PositiveIntegerField()
     author     = models.ForeignKey('auth.User', related_name='%(class)ss')
@@ -198,16 +196,13 @@ class PostRevision(models.Model):
         return u'%s - revision %s of %s' % (self.revision_type_str(), self.revision, self.title)
 
     def parent(self):
-        if self.is_question_revision():
-            return self.question
-        elif self.is_answer_revision():
-            return self.answer
+        return self.post
 
     def clean(self):
         "Internal cleaning method, called from self.save() by self.full_clean()"
-        if bool(self.question) == bool(self.answer): # one and only one has to be set (!xor)
-            raise ValidationError('One (and only one) of question/answer fields has to be set.')
-        if (self.question and not self.is_question_revision()) or (self.answer and not self.is_answer_revision()):
+        # TODO: Remove this when we remove `revision_type`
+        if (self.post.post_type == 'question' and not self.is_question_revision()) or \
+           (self.post.post_type == 'answer' and not self.is_answer_revision()):
             raise ValidationError('Revision_type doesn`t match values in question/answer fields.')
 
     def save(self, **kwargs):
diff --git a/askbot/models/question.py b/askbot/models/question.py
index 61626662..73d770a6 100644
--- a/askbot/models/question.py
+++ b/askbot/models/question.py
@@ -63,7 +63,8 @@ class ThreadManager(models.Manager):
 
         thread = super(ThreadManager, self).create(title=title, tagnames=tagnames, last_activity_at=added_at, last_activity_by=author)
 
-        question = Question(
+        question = Post(
+            post_type='question',
             thread=thread,
             author = author,
             added_at = added_at,
@@ -340,7 +341,7 @@ class Thread(models.Model):
         self.save()
 
     def set_accepted_answer(self, answer, timestamp):
-        if answer and answer.question.thread != self:
+        if answer and answer.thread != self:
             raise ValueError("Answer doesn't belong to this thread")
         self.accepted_answer = answer
         self.answer_accepted_at = timestamp
@@ -544,7 +545,7 @@ class Thread(models.Model):
         # Create a new revision
         latest_revision = thread_question.get_latest_revision()
         PostRevision.objects.create_question_revision(
-            question   = thread_question,
+            post = thread_question,
             title      = latest_revision.title,
             author     = retagged_by,
             revised_at = retagged_at,
diff --git a/askbot/models/repute.py b/askbot/models/repute.py
index b7e54d87..dce907ac 100644
--- a/askbot/models/repute.py
+++ b/askbot/models/repute.py
@@ -109,7 +109,7 @@ class Repute(models.Model):
     #todo: combine positive and negative to one value
     positive = models.SmallIntegerField(default=0)
     negative = models.SmallIntegerField(default=0)
-    question_post = models.ForeignKey('Post', null=True, blank=True)
+    question = models.ForeignKey('Post', null=True, blank=True)
     reputed_at = models.DateTimeField(default=datetime.datetime.now)
     reputation_type = models.SmallIntegerField(choices=const.TYPE_REPUTATION)
     reputation = models.IntegerField(default=1)
@@ -145,7 +145,7 @@ class Repute(models.Model):
             link_title_data = {
                                 'points': abs(delta),
                                 'username': self.user.username,
-                                'question_title': self.question_post.thread.title
+                                'question_title': self.question.thread.title
                             }
             if delta > 0:
                 link_title = _(
@@ -161,6 +161,6 @@ class Repute(models.Model):
             return '<a href="%(url)s" title="%(link_title)s">%(question_title)s</a>' \
                             % {
                                'url': self.question.get_absolute_url(), 
-                               'question_title': self.question_post.thread.title,
+                               'question_title': self.question.thread.title,
                                'link_title': link_title
                             }
diff --git a/askbot/skins/default/templates/answer_edit.html b/askbot/skins/default/templates/answer_edit.html
index bbf3edef..5f563b8f 100644
--- a/askbot/skins/default/templates/answer_edit.html
+++ b/askbot/skins/default/templates/answer_edit.html
@@ -7,7 +7,7 @@
 {% endblock %}
 {% block content %}
 <h1 class="section-title">
-    {% trans %}Edit answer{% endtrans %} [<a href="{{ answer.question.get_absolute_url() }}#{{ answer.id }}">{% trans %}back{% endtrans %}</a>]
+    {% trans %}Edit answer{% endtrans %} [<a href="{{ answer.thread._question_post().get_absolute_url() }}#{{ answer.id }}">{% trans %}back{% endtrans %}</a>]
 </h1>
 <div id="main-body" class="ask-body">
     <form id="fmedit" action="{% url edit_answer answer.id %}" method="post" >{% csrf_token %}
diff --git a/askbot/views/commands.py b/askbot/views/commands.py
index e0e83209..771b69fb 100644
--- a/askbot/views/commands.py
+++ b/askbot/views/commands.py
@@ -97,11 +97,7 @@ def process_vote(user = None, vote_direction = None, post = None):
     if user.is_anonymous():
         raise exceptions.PermissionDenied(_('anonymous users cannot vote'))
 
-    user.assert_can_vote_for_post(
-                                    post = post,
-                                    direction = vote_direction
-                                )
-
+    user.assert_can_vote_for_post(post = post, direction = vote_direction)
     vote = user.get_old_vote_for_post(post)
     response_data = {}
     if vote != None:
@@ -196,8 +192,7 @@ def vote(request, id):
         if vote_type == '0':
             if request.user.is_authenticated():
                 answer_id = request.POST.get('postId')
-                answer = get_object_or_404(models.Answer, id = answer_id)
-                question = answer.question
+                answer = get_object_or_404(models.Post, post_type='answer', id = answer_id)
                 # make sure question author is current user
                 if answer.accepted():
                     request.user.unaccept_best_answer(answer)
@@ -222,9 +217,9 @@ def vote(request, id):
                 #todo: fix this weirdness - why postId here
                 #and not with question?
                 id = request.POST.get('postId')
-                post = get_object_or_404(models.Answer, id=id)
+                post = get_object_or_404(models.Post, post_type='answer', id=id)
             else:
-                post = get_object_or_404(models.Question, id=id)
+                post = get_object_or_404(models.Post, post_type='question', id=id)
             #
             ######################
 
@@ -237,10 +232,10 @@ def vote(request, id):
         elif vote_type in ['7', '8']:
             #flag question or answer
             if vote_type == '7':
-                post = get_object_or_404(models.Question, id=id)
+                post = get_object_or_404(models.Post, post_type='question', id=id)
             if vote_type == '8':
                 id = request.POST.get('postId')
-                post = get_object_or_404(models.Answer, id=id)
+                post = get_object_or_404(models.Post, post_type='answer', id=id)
 
             request.user.flag_post(post)
 
@@ -250,10 +245,10 @@ def vote(request, id):
         elif vote_type in ['7.5', '8.5']:
             #flag question or answer
             if vote_type == '7.5':
-                post = get_object_or_404(models.Question, id=id)
+                post = get_object_or_404(models.Post, post_type='question', id=id)
             if vote_type == '8.5':
                 id = request.POST.get('postId')
-                post = get_object_or_404(models.Answer, id=id)
+                post = get_object_or_404(models.Post, post_type='answer', id=id)
 
             request.user.flag_post(post, cancel = True)
 
@@ -262,10 +257,10 @@ def vote(request, id):
 
         elif vote_type in ['9', '10']:
             #delete question or answer
-            post = get_object_or_404(models.Question, id = id)
+            post = get_object_or_404(models.Post, post_type='question', id=id)
             if vote_type == '10':
                 id = request.POST.get('postId')
-                post = get_object_or_404(models.Answer, id = id)
+                post = get_object_or_404(models.Post, post_type='answer', id=id)
 
             if post.deleted == True:
                 request.user.restore_post(post = post)
@@ -278,12 +273,11 @@ def vote(request, id):
                 response_data['allowed'] = 0
                 response_data['success'] = 0
 
-            question = get_object_or_404(models.Question, id=id)
+            question = get_object_or_404(models.Post, post_type='question', id=id)
             vote_type = request.POST.get('type')
 
             #accept answer
             if vote_type == '4':
-                has_favorited = False
                 fave = request.user.toggle_favorite_question(question)
                 response_data['count'] = models.FavoriteQuestion.objects.filter(thread = question.thread).count()
                 if fave == False:
@@ -475,7 +469,7 @@ def close(request, id):#close question
     """view to initiate and process
     question close
     """
-    question = get_object_or_404(models.Question, id=id)
+    question = get_object_or_404(models.Post, post_type='question', id=id)
     try:
         if request.method == 'POST':
             form = forms.CloseForm(request.POST)
@@ -508,7 +502,7 @@ def reopen(request, id):#re-open question
     this is not an ajax view
     """
 
-    question = get_object_or_404(models.Question, id=id)
+    question = get_object_or_404(models.Post, post_type='question', id=id)
     # open question
     try:
         if request.method == 'POST' :
@@ -556,7 +550,7 @@ def upvote_comment(request):
     if form.is_valid():
         comment_id = form.cleaned_data['post_id']
         cancel_vote = form.cleaned_data['cancel_vote']
-        comment = models.Comment.objects.get(id = comment_id)
+        comment = get_object_or_404(models.Post, post_type='comment', id=comment_id)
         process_vote(
             post = comment,
             vote_direction = 'up',
diff --git a/askbot/views/readers.py b/askbot/views/readers.py
index 6379a002..6b3889e5 100644
--- a/askbot/views/readers.py
+++ b/askbot/views/readers.py
@@ -416,7 +416,7 @@ def question(request, id):#refactor - long subroutine. display question body, an
         #and that the visitor is allowed to see it
         try:
             show_post = get_object_or_404(models.Post, id=show_answer)
-            if str(show_post.question_id) != id:
+            if str(show_post.thread._question_post().id) != id:
                 return HttpResponseRedirect(show_post.get_absolute_url())
             show_post.assert_is_visible_to(request.user)
         except django_exceptions.PermissionDenied, error:
@@ -467,7 +467,7 @@ def question(request, id):#refactor - long subroutine. display question body, an
     if request.user.is_authenticated():
         votes = Vote.objects.filter(user=request.user, voted_post__in=answers)
         for vote in votes:
-            user_answer_votes[vote.post.id] = int(vote)
+            user_answer_votes[vote.voted_post.id] = int(vote)
 
     filtered_answers = [answer for answer in answers if ((not answer.deleted) or (answer.deleted and answer.author_id == request.user.id))]
 
@@ -570,10 +570,9 @@ def question(request, id):#refactor - long subroutine. display question body, an
 def revisions(request, id, object_name=None):
     if object_name == 'Question':
         post = get_object_or_404(models.Post, post_type='question', id=id)
-        revisions = list(models.PostRevision.objects.filter(question=post))
     else:
         post = get_object_or_404(models.Post, post_type='answer', id=id)
-        revisions = list(models.PostRevision.objects.filter(answer=post))
+    revisions = list(models.PostRevision.objects.filter(post=post))
     revisions.reverse()
     for i, revision in enumerate(revisions):
         revision.html = revision.as_html()
diff --git a/askbot/views/writers.py b/askbot/views/writers.py
index 883f1a39..e50214af 100644
--- a/askbot/views/writers.py
+++ b/askbot/views/writers.py
@@ -550,7 +550,7 @@ def __generate_comments_json(obj, user):#non-view generates json data for the po
                 is_deletable = True
             except exceptions.PermissionDenied:
                 is_deletable = False
-            is_editable = template_filters.can_edit_comment(comment.user, comment)
+            is_editable = template_filters.can_edit_comment(comment.author, comment)
         else:
             is_deletable = False
             is_editable = False
@@ -585,10 +585,7 @@ def post_comments(request):#generic ajax handler to load comments to an object
     user = request.user
 
     id = request.REQUEST['post_id']
-    if post_type == 'question':
-        obj = get_object_or_404(models.Post, id=id)
-    else: #if post_type == 'answer':
-        obj = get_object_or_404(models.Post, id=id)
+    obj = get_object_or_404(models.Post, id=id)
 
     if request.method == "GET":
         response = __generate_comments_json(obj, user)
@@ -614,7 +611,7 @@ def edit_comment(request):
         raise exceptions.PermissionDenied(_('Sorry, anonymous users cannot edit comments'))
 
     comment_id = int(request.POST['comment_id'])
-    comment_post = models.Post.objects.get(id=comment_id)
+    comment_post = models.Post.objects.get(post_type='comment', id=comment_id)
 
     request.user.edit_comment(comment_post=comment_post, body_text = request.POST['comment'])
 
@@ -648,17 +645,16 @@ def delete_comment(request):
         if request.is_ajax():
 
             comment_id = request.POST['comment_id']
-            comment = get_object_or_404(models.Comment, id=comment_id)
+            comment = get_object_or_404(models.Post, post_type='comment', id=comment_id)
             request.user.assert_can_delete_comment(comment)
 
-            obj = comment.content_object
-            #todo: are the removed comments actually deleted?
-            obj.comments.remove(comment)
+            parent = comment.parent
+            comment.delete()
             #attn: recalc denormalized field
-            obj.comment_count = obj.comment_count - 1
-            obj.save()
+            parent.comment_count = parent.comment_count - 1
+            parent.save()
 
-            return __generate_comments_json(obj, request.user)
+            return __generate_comments_json(parent, request.user)
 
         raise exceptions.PermissionDenied(
                     _('sorry, we seem to have some technical difficulties')