def get(self, *args):
(forum, siteroot, tmpldir) = forum_siteroot_tmpldir_from_url(self.request.path_info)
if not forum or forum.is_disabled:
return self.redirect(FORUMS_ROOT + "/")
is_moderator = users.is_current_user_admin()
if not is_moderator or forum.is_disabled:
return self.redirect(siteroot)
post_id = self.request.query_string
#logging.info("PostDelUndel: post_id='%s'" % post_id)
post = db.get(db.Key.from_path('Post', int(post_id)))
if not post:
logging.info("No post with post_id='%s'" % post_id)
return self.redirect(siteroot)
if post.forum.key() != forum.key():
loggin.info("post.forum.key().id() ('%s') != fourm.key().id() ('%s')" % (str(post.forum.key().id()), str(forum.key().id())))
return self.redirect(siteroot)
path = self.request.path
if path.endswith("/postdel"):
if not post.is_deleted:
post.is_deleted = True
post.put()
memcache.delete(rss_memcache_key(forum))
else:
logging.info("Post '%s' is already deleted" % post_id)
elif path.endswith("/postundel"):
if post.is_deleted:
post.is_deleted = False
post.put()
memcache.delete(rss_memcache_key(forum))
else:
logging.info("Trying to undelete post '%s' that is not deleted" % post_id)
else:
logging.info("'%s' is not a valid path" % path)
topic = post.topic
# deleting/undeleting first post also means deleting/undeleting the whole topic
first_post = Post.gql("WHERE forum=:1 AND topic = :2 ORDER BY created_on", forum, topic).get()
if first_post.key() == post.key():
if path.endswith("/postdel"):
topic.is_deleted = True
else:
topic.is_deleted = False
topic.put()
clear_topics_memcache(forum)
# redirect to topic owning this post
topic_url = siteroot + "topic?id=" + str(topic.key().id())
self.redirect(topic_url)
def delete(self):
"""Do the normal delete() and invalidate memcache."""
super(AnnouncementEntity, self).delete()
MemcacheManager.delete(self.memcache_key)
def put(self):
"""Do the normal put() and also invalidate memcache."""
result = super(AnnouncementEntity, self).put()
MemcacheManager.delete(self.memcache_key)
return result
def delete(self):
"""Do the normal delete() and invalidate memcache."""
super(AnnouncementEntity, self).delete()
MemcacheManager.delete(self.memcache_key)
def put(self):
"""Do the normal put() and also invalidate memcache."""
result = super(AnnouncementEntity, self).put()
MemcacheManager.delete(self.memcache_key)
return result
def delete(self):
"""Do the normal delete() and invalidate memcache."""
super(StudentAnswersEntity, self).delete()
MemcacheManager.delete(self.memcache_key)
def delete(self):
"""Do the normal delete() and invalidate memcache."""
super(StudentAnswersEntity, self).delete()
MemcacheManager.delete(self.memcache_key)
def post(self, *args):
if not self.personalize_page_and_get_enrolled():
return
(forum, siteroot, tmpldir) = forum_siteroot_tmpldir_from_url(self.request.path_info)
if not forum or forum.is_disabled:
return self.redirect(FORUMS_ROOT + "/")
if self.request.get('Cancel'):
return self.redirect(siteroot)
ip = get_remote_ip()
if ip in BANNED_IPS:
return self.redirect(siteroot)
self.send_cookie()
vals = ['TopicId', 'Subject', 'Message', ]
(topic_id, subject, message) = req_get_vals(self.request, vals)
message = to_unicode(message)
tvals = {
'siteroot' : siteroot,
'forums' : db.GqlQuery("SELECT * FROM Forum where is_disabled = False").fetch(MAX_FORUMS),
'forum' : forum,
"prevSubject" : subject,
"prevMessage" : message,
"log_in_out" : get_log_in_out(siteroot + "post")
}
# validate captcha and other values
errclass = None
if not message: errclass = "message_class"
# first post must have subject
if not topic_id and not subject: errclass = "subject_class"
# sha.new() doesn't accept Unicode strings, so convert to utf8 first
message_utf8 = message.encode('UTF-8')
s = sha.new(message_utf8)
sha1_digest = s.hexdigest()
duppost = Post.gql("WHERE sha1_digest = :1", sha1_digest).get()
if duppost: errclass = "message_class"
if errclass:
tvals[errclass] = "error"
tmpl = os.path.join(tmpldir, "post.html")
return self.template_out(tmpl, tvals)
# get user either by google user id or cookie. Create user objects if don't
# already exist
existing_user = False
user_id = users.get_current_user()
if not user_id:
self.redirect("/")
return
user = Student.get_enrolled_student_by_email(user_id.email())
if not user:
self.redirect("/")
return
if not topic_id:
topic = Topic(forum=forum, subject=subject, created_by=user.name)
topic.put()
else:
topic = db.get(db.Key.from_path('Topic', int(topic_id)))
#assert forum.key() == topic.forum.key()
topic.ncomments += 1
topic.put()
notify_addr = '*****@*****.**'
if notify_addr:
mail.send_mail(sender=notify_addr,
to=notify_addr,
subject="[booc-iu] New forum post",
body=Markup("Topic: %s\n%s\n%s") % (
topic.subject,
self.request.host_url + siteroot + "topic?id=" + str(topic.key().id()),
message))
user_ip_str = get_remote_ip()
if user.wiki_id:
user_profile_link = '/wikiprofile?student=%d' % user.wiki_id
else:
user_profile_link = ''
p = Post(topic=topic, forum=forum, user=user, user_ip=0, user_ip_str=user_ip_str, message=message, sha1_digest=sha1_digest, user_name = user.name, user_email = user_id.email(), user_homepage = user_profile_link)
p.put()
memcache.delete(rss_memcache_key(forum))
clear_topics_memcache(forum)
if topic_id:
self.redirect(siteroot + "topic?id=" + str(topic_id))
else:
self.redirect(siteroot)
def clear_topics_memcache(forum): memcache.delete(topics_memcache_key(forum))
def delete(self, *args, **kwargs):
return MemcacheManager.delete(*args, **kwargs)
def clear_forums_memcache(): memcache.delete(FORUMS_MEMCACHE_KEY)
def delete(self):
"""Do the normal delete() and also remove the object from memcache."""
super(Teacher, self).delete()
MemcacheManager.delete(self._memcache_key(self.key().name()))
def delete(self, *args, **kwargs):
return MemcacheManager.delete(*args, **kwargs)
def delete(self):
"""Do the normal delete() and also remove the object from memcache."""
super(ProgrammingAnswersEntity, self).delete()
MemcacheManager.delete(self._memcache_key(self.key().name()))
def delete(self):
"""Do the normal delete() and invalidate memcache."""
super(CourseSectionEntity, self).delete()
MemcacheManager.delete(self.memcache_key)
def delete(self):
"""Do the normal delete() and invalidate memcache."""
super(CourseSectionEntity, self).delete()
MemcacheManager.delete(self.memcache_key)
