def get(self, *args, **kwargs):
     # pre_get can be a coroutine in subclasses
     # assign and yield in two step to avoid tornado 3 issues
     res = self.pre_get()
     yield gen.maybe_future(res)
     res = super(AuthenticatedZMQStreamHandler, self).get(*args, **kwargs)
     yield gen.maybe_future(res)

    def post(self):
        username = self.get_argument('username', None)
        password = self.get_argument('password', None)
        email = self.get_argument('email', None)
        avatar = self.default_avatar_url

        if username is None or password is None or email is None:
            raise exceptions.EmptyFields()
        else:
            user = yield gen.maybe_future(User.get_by_name(username))
            if user is not None:
                raise exceptions.UsernameAlreadyExists()
            user = yield gen.maybe_future(User.get_by_email(email))
            if user is not None:
                raise exceptions.EmailAlreadyExists()
            password = encrypt_password(password)
            user = yield gen.maybe_future(
                User.create(username=username, password=password,
                            email=email, avatar=avatar))

            # Update permission after xxx seconds.
            seconds = Level['time'][Roles.Comment]
            wait = datetime.now(get_localzone()) + timedelta(seconds=seconds)
            update_permission.apply_async((user, Roles.Comment), eta=wait)

            # Register success, then login.
            token = set_cookie_session(self, username, 1)
            raise gen.Return({'username': username, 'token': token})

    def post(self, topic_id):
        name = self.get_argument('name', None)
        description = self.get_argument('description', None)
        rules = self.get_argument('rules', None)
        avatar = self.get_argument('avatar', None)
        why = self.get_argument('why', None)

        if not all([name, description, rules, why]):
            raise exceptions.EmptyFields()
        else:
            exists = yield gen.maybe_future(Topic.get_by_name(name))
            if exists:
                raise exceptions.TopicNameAlreadyExists()
            else:
                created_user = self.current_user
                topic = yield gen.maybe_future(
                    Topic.create(name, created_user, avatar,
                                 description, rules, why))

                # Update Gold.
                update_gold.apply_async(('new_proposal', created_user))

                # Update proposal state.
                seconds = Level['time']['proposal']
                wait = datetime.now(get_localzone()) + timedelta(seconds=seconds)
                check_proposal.apply_async((topic.id,), eta=wait)

    def post(self, topic_id):
        title = self.get_argument('title', None)
        keywords = self.get_argument('keywords', None)
        content = self.get_argument('content', '')
        keep_silent = int(self.get_argument('keep_silent', 0))
        is_draft = int(self.get_argument('is_draft', 0))

        if not all([title, keywords]):
            raise exceptions.EmptyFields()
        else:
            can_post = yield gen.maybe_future(Topic.can_post(topic_id))
            if not can_post:
                raise exceptions.TopicIsNotAccepted
            exists = yield gen.maybe_future(Post.get_by_title(title))
            if exists:
                raise exceptions.PostTitleAlreadyExists()
            else:
                username = self.current_user
                yield gen.maybe_future(
                    Post.create(username, topic_id,
                                title, keywords, content,
                                keep_silent=keep_silent, is_draft=is_draft))

                # Update gold.
                update_gold.apply_async(('new_post', username))

    def check_image(self, kw):
        if self.context.config.MAX_ID_LENGTH > 0:
            # Check if an image with an uuid exists in storage
            exists = yield gen.maybe_future(
                self.context.modules.storage.exists(kw["image"][: self.context.config.MAX_ID_LENGTH])
            )
            if exists:
                kw["image"] = kw["image"][: self.context.config.MAX_ID_LENGTH]

        url = self.request.uri

        if not self.validate(kw["image"]):
            self._error(400, "No original image was specified in the given URL")
            return

        kw["request"] = self.request
        kw["image"] = quote(kw["image"].encode("utf-8"))
        kw["config"] = self.context.config

        self.context.request = RequestParameters(**kw)

        has_none = not self.context.request.unsafe and not self.context.request.hash
        has_both = self.context.request.unsafe and self.context.request.hash

        if has_none or has_both:
            self._error(400, "URL does not have hash or unsafe, or has both: %s" % url)
            return

        if self.context.request.unsafe and not self.context.config.ALLOW_UNSAFE_URL:
            self._error(400, "URL has unsafe but unsafe is not allowed by the config: %s" % url)
            return

        if self.context.config.USE_BLACKLIST:
            blacklist = yield self.get_blacklist_contents()
            if self.context.request.image_url in blacklist:
                self._error(400, "Source image url has been blacklisted: %s" % self.context.request.image_url)
                return

        url_signature = self.context.request.hash
        if url_signature:
            signer = self.context.modules.url_signer(self.context.server.security_key)

            url_to_validate = Url.encode_url(url).replace("/%s/" % self.context.request.hash, "")
            valid = signer.validate(url_signature, url_to_validate)

            if not valid and self.context.config.STORES_CRYPTO_KEY_FOR_EACH_IMAGE:
                # Retrieves security key for this image if it has been seen before
                security_key = yield gen.maybe_future(
                    self.context.modules.storage.get_crypto(self.context.request.image_url)
                )
                if security_key is not None:
                    signer = self.context.modules.url_signer(security_key)
                    valid = signer.validate(url_signature, url_to_validate)

            if not valid:
                self._error(400, "Malformed URL: %s" % url)
                return

        self.execute_image_operations()

 def get(self):
     username = self.current_user
     subs = yield gen.maybe_future(Subscription.list_by_user(username))
     result = {
         'total': len(subs),
         'topics': [(yield gen.maybe_future(s.to_dict())) for s in subs],
     }
     raise gen.Return(result)

 def delete(self, topic_id):
     username = self.current_user
     s = yield gen.maybe_future(
         Subscription.get_by_user_topic(username, topic_id))
     if s:
         yield gen.maybe_future(s.delete())
     else:
         raise exceptions.TopicHasNotBeenSubscribed()

 def get(self, path='', commit='HEAD', path2=None):
     """runs nbdiff for a given notebook"""
     cm = self.contents_manager
     if path2:
         diff = yield gen.maybe_future(cm.file_diff(path, path2))
     else:
         diff = yield gen.maybe_future(cm.git_diff(path, commit))
     self.finish(diff)

 def post(self, topic_id):
     username = self.current_user
     s = yield gen.maybe_future(
         Subscription.get_by_user_topic(username, topic_id))
     if s:
         raise exceptions.TopicAlreadySubscribed()
     else:
         yield gen.maybe_future(Subscription.create(username, topic_id))

    def get_blacklist_contents(self):
        filename = 'blacklist.txt'

        exists = yield gen.maybe_future(self.context.modules.storage.exists(filename))
        if exists:
            blacklist = yield gen.maybe_future(self.context.modules.storage.get(filename))
            raise tornado.gen.Return(blacklist)
        else:
            raise tornado.gen.Return("")

    def get(self):
        count = int(self.get_argument('count', 4))

        ans = yield gen.maybe_future(Announcement.list_by_count(count))
        raise gen.Return({
            'total': len(ans),
            'announcements': [(yield gen.maybe_future(an.to_dict()))
                              for an in ans]
        })

	def trigger_reactions(self):
		if self.cbs:
			cb = self.cbs.pop()
			if self.react_data is None:
				drew_cards = yield gen.maybe_future(cb())
				yield self.reacted(drew_cards)
			else:
				drew_cards = yield gen.maybe_future(cb(self.react_data))
				yield self.reacted(drew_cards)

 def data_received(self, chunk):
     if self._decompressor:
         compressed_data = chunk
         while compressed_data:
             decompressed = self._decompressor.decompress(compressed_data, self._chunk_size)
             if decompressed:
                 yield gen.maybe_future(self._delegate.data_received(decompressed))
             compressed_data = self._decompressor.unconsumed_tail
     else:
         yield gen.maybe_future(self._delegate.data_received(chunk))

    def post(self):
        # Creates a new session
        #(unless a session already exists for the named session)
        sm = self.session_manager

        model = self.get_json_body()
        if model is None:
            raise web.HTTPError(400, "No JSON data provided")

        if 'notebook' in model and 'path' in model['notebook']:
            self.log.warn('Sessions API changed, see updated swagger docs')
            model['path'] = model['notebook']['path']
            model['type'] = 'notebook'

        try:
            path = model['path']
        except KeyError:
            raise web.HTTPError(400, "Missing field in JSON data: path")

        try:
            mtype = model['type']
        except KeyError:
            raise web.HTTPError(400, "Missing field in JSON data: type")

        name = model.get('name', None)
        kernel = model.get('kernel', {})
        kernel_name = kernel.get('name', None)
        kernel_id = kernel.get('id', None)

        if not kernel_id and not kernel_name:
            self.log.debug("No kernel specified, using default kernel")
            kernel_name = None

        exists = yield gen.maybe_future(sm.session_exists(path=path))
        if exists:
            model = yield gen.maybe_future(sm.get_session(path=path))
        else:
            try:
                model = yield gen.maybe_future(
                    sm.create_session(path=path, kernel_name=kernel_name,
                                      kernel_id=kernel_id, name=name,
                                      type=mtype))
            except NoSuchKernel:
                msg = ("The '%s' kernel is not available. Please pick another "
                       "suitable kernel instead, or install that kernel." % kernel_name)
                status_msg = '%s not found' % kernel_name
                self.log.warning('Kernel not found: %s' % kernel_name)
                self.set_status(501)
                self.finish(json.dumps(dict(message=msg, short_message=status_msg)))
                return

        location = url_path_join(self.base_url, 'api', 'sessions', model['id'])
        self.set_header('Location', location)
        self.set_status(201)
        self.finish(json.dumps(model, default=date_default))

 def delete(self, post_id):
     username = self.current_user
     f = yield gen.maybe_future(Favorite.get_by_user_post(username, post_id))
     if f:
         yield gen.maybe_future(f.delete())
         count = yield gen.maybe_future(Favorite.count_by_post(post_id))
         # Update gold.
         update_gold.apply_async(("cancel_post_be_favorite", post_id))
         raise gen.Return({"count": count})
     else:
         raise exceptions.PostHasNotBeenFavorited()

 def post(self, post_id):
     username = self.current_user
     f = yield gen.maybe_future(Favorite.get_by_user_post(username, post_id))
     if f:
         raise exceptions.PostAlreadyFavorited()
     else:
         yield gen.maybe_future(Favorite.create(username, post_id))
         count = yield gen.maybe_future(Favorite.count_by_post(post_id))
         # Update gold.
         update_gold.apply_async(("post_be_favorite", post_id))
         raise gen.Return({"count": count})

	def gain_helper(self, card_obj, from_supply=True, announcement=None):
		if announcement is not None and announcement is not "":
			self.game.announce(announcement)
		self.discard_pile.append(card_obj)
		self.update_discard_size()
		yield gen.maybe_future(card_obj.on_gain())
		yield gen.maybe_future(self.hand.do_reactions("Gain", card_obj))
		for i in self.get_opponents():
			yield gen.maybe_future(i.hand.do_reactions("OpponentGain", card_obj))
		if card_obj in self.all_cards():
			yield gen.maybe_future(self.resolve_on_gain_effects(card_obj))

 def get(self):
     users = yield gen.maybe_future(User.count())
     topics = yield gen.maybe_future(Topic.count())
     posts = yield gen.maybe_future(Post.count())
     comments = yield gen.maybe_future(Comment.count())
     raise gen.Return({
         'users_count': users,
         'topics_count': topics,
         'posts_count': posts,
         'comments_count': comments,
     })

    def post(self):
        username = self.current_user

        robed = gold.get(username, random_gold)
        if robed == -1:
            raise exceptions.CanNotRobAgain()
        elif robed == 0:
            raise exceptions.NoMoreGoldToday()
        user = yield gen.maybe_future(User.get_by_name(username))
        yield gen.maybe_future(user.update(gold=robed))
        raise gen.Return({'gold': robed})

    def patch(self, post_id):
        keywords = self.get_argument('keywords', None)
        content = self.get_argument('content', None)
        keep_silent = int(self.get_argument('keep_silent', 0))
        is_draft = int(self.get_argument('is_draft', 0))

        if keywords is None and content is None and keep_silent is None:
            raise exceptions.EmptyFields()
        else:
            post = yield gen.maybe_future(Post.get(post_id))
            yield gen.maybe_future(
                post.update(keywords, content, keep_silent, is_draft))