def handle(self, env, start_response):
        url = env['PATH_INFO'].strip('/')
        method = env['REQUEST_METHOD']
        handler =  self.handlers.get(url)
        if handler:
            if method in handler:
                req = Request(env)
                res = Response()
                content = handler[method](req, res)
                template = handler['TEMPLATE']
                template_dir = handler['TEMPLATE_DIR']

                if isinstance(content, dict): #possibly wrapped by @template
                    if 'template' in content:
                        template = content['template']
                        content = content['content']

                if isinstance(content, HTTPError):
                    content = getattr(content, method.lower())(req, res)
                elif template and isinstance(content, dict):
                    template = os.path.join(template_dir, template)
                    content = str(Template(self.get_template(template)).render(content))
                    res.content_type = 'text/html'
                elif isinstance(content, dict):
                    content = json.dumps(content)
                    res.content_type = 'application/json'
                elif not content:
                    content = ''

                res.content_length = str(len(content))
                start_response(res.status, res.headers)
                return [content]

class Manager():

    def __init__(self):
        self.ivizion = Ivizion()
        self.ivizion.connect()
        self.message = Message()
        self.response = Response()

    def send_command(self, lng=LNG_5, cmd=RESET, data1='', data2=''):
        self.message.update_message(lng=lng, cmd=cmd, data1=data1, data2=data2)
        msg = self.message.get_message()
        self.ivizion.send(msg)

    def get_status(self):
        self.message.update_message()
        msg = self.message.get_message()
        self.ivizion.send(msg)
        answer = self.ivizion.recipe()
        return answer[4:6]

    def show_status(self):
        self.message.update_message()
        msg = self.message.get_message()
        self.ivizion.send(msg)
        answer = self.ivizion.recipe()
        self.response.show_response(answer, REQ_STATUS)

    def get_escrow(self):
        self.message.update_message()
        msg = self.message.get_message()
        self.ivizion.send(msg)
        answer = self.ivizion.recipe()
        return self.response.get_escrow(answer)

def pe_ratio(ticker, components): 
	quote = data.get_quote_yahoo(ticker)
	PE = quote['PE'][0]
	if PE=='N/A':
		return {"message": Response.pe_notfound(ticker)}
	PE = ('%.2f' % PE)
	return {"message": Response.pe_response(ticker, PE)}

 def test_200_response(self):
     body = ['test response body']
     headers = {'Content-type': 'application/json', 'Content-length': str(len(json.dumps(body))), 'Foo': 'bar', 'Baz': 'Quux'}
     headers_string = '\r\n'.join([': '.join([header, headers[header]]) for header in headers])
     response = Response(status=200, headers=headers, body=body)
     
     self.assertEqual(response.raw(), self.response_template % ('200 OK', headers_string, json.dumps(body)))

 def login_client(self, request):
     client_name = request.parameters['name']
     client_pass = request.parameters['pass']
     if self.manager.login(client_name, client_pass):
         response = Response.create_client()
     else:
         response = Response.create_login()
     return response

def last_price(ticker): 
	ticker = ticker.upper()
	price = Share(ticker).get_price()
	if not price: 
		return Response.last_price_notfound(ticker)
	trade_datetime = Share(ticker).get_trade_datetime().split(' ')
	month, day = calendar.month_name[int(trade_datetime[0][5:7].lstrip('0'))], trade_datetime[0][8:10].lstrip('0')
	trade_time = trade_datetime[1] + " UTC+0"
	return Response.last_price(ticker, price, month, day, trade_time)

    def respond_to_edit_request(self, message):
        """ Responds to an edit request. The bot will parse the body of the message, looking for verse
        quotations. These will replace the quotations that were placed in the original response to the
        user. Once the comment has been successfully edited, the bot then sends a message to the user
        letting them know that their verse quotations have been updated. """

        try:
            comment_url = message.body[1:message.body.find("}")]
            comment = self.r.get_submission(comment_url)
        except:
            try:
                message.reply("An error occurred while processing your edit request. "
                    "Please make sure that you do not modify the subject line of your message to %s."
                    % REDDIT_USERNAME)
            except requests.exceptions.ConnectionError:
                pass
            return

        if message.author == comment.author and comment:
            verses = find_verses(message.body)
            if verses is not None:
                for reply in comment.comments[0].replies:
                    if str(reply.author) == REDDIT_USERNAME:
                        try:
                            self.log.info("%s has requested a comment edit..." % comment.author)
                            link = reply.permalink[24:comment.permalink.find("/", 24)]
                            response = Response(message, self.parser, comment_url)
                            for verse in verses:
                                book_name = books.get_book(verse[0])
                                if book_name is not None:
                                    v = Verse(book_name,  # Book
                                        verse[1],  # Chapter
                                        verse[3],  # Translation
                                        message.author,  # User
                                        link,  # Subreddit
                                        verse[2])  # Verse
                                    if not response.is_duplicate_verse(v):
                                        response.add_verse(v)
                            if len(response.verse_list) != 0:
                                message_response = ("*^This ^comment ^has ^been ^edited ^by ^%s.*\n\n" % message.author)
                                message_response += response.construct_message()
                                if message_response is not None:
                                    self.log.info("Editing %s's comment with updated verse quotations..." % message.author)
                                    database.remove_invalid_statistics(reply.body, link)
                                    reply.edit(message_response)
                                    database.update_db_stats(response.verse_list)
                                    try:
                                        message.reply("[Your triggered %s response](%s) has been successfully edited to reflect"
                                            " your updated quotations." % (REDDIT_USERNAME, comment_url))
                                    except requests.exceptions.ConnectionError:
                                        pass
                                    break
                        except:
                            raise
                            self.log.warning("Comment edit failed. Will try again later...")
                            break

 def request(self, action, xml):
     try:
         return Response(self.client.send(action, xml), action, True)
     except SocketError as e:
         if e.errno == errno.ECONNRESET:
             response_error = Response("ECONNRESET", action)
             response_error.error, response_error.error_msg = "ECONNRESET", "[Errno 104] Connection reset by peer"
             return response_error
         else:
             raise

def submit(d):
    header = Header(d["method"], d["path"], d["httpversion"])
    for i in d['headers']:
        header.add_header(i['header_name'], i['header_value'])
    header.build_from_text()
    print(header.payload)
    s = Sender()
    r = Response()
    resp = r.input_text(s.send(d["protocol"], d["hostname"], header.payload))
    return resp

def name_exchange(ticker, components): 
	exchanges = {"NMS": "NASDAQ", "NGM": "NASDAQ", "NYQ":"NYSE"}
	try: 
		info = data.get_components_yahoo(ticker)
	except Exception: 
		return {"message": Response.data_notfound(ticker)}
	name, symbol = info['name'][0], info['exchange'][0]
	exchange = exchanges.get(symbol)
	if not exchange: 
		exchange = symbol
	return {"message": Response.name_exchange_response(ticker, name, exchange)}

 def test_parse_links(self):
     for idx in range(len(testdata)):
         print idx
         s = Response(testdata[idx])
         links_obj = s.parse_links(testdata[idx]['_links'])
         self.assertFalse(links_obj=={}) # must return a valid object
         self.assertEqual(links_obj,s._response['_links'])
         for link in links_obj:
             self.assertIn(link,expected_links) # fixed set of expected links
             self.assertTrue(links_obj[link]) # cannot have empty string for link url
             print '{0} : {1}'.format(link,links_obj[link])
     pass

    def respond_to_username_mention(self, msg):
        """ Responds to a username mention. This could either contain one or
        more valid Bible verse quotation requests, or it could simply be a
        username mention without any valid Bible verses. If there are valid
        Bible verses, VerseBot generates a response that contains the text
        from these quotations. Otherwise, the message is forwarded to the
        VerseBot admin for review.

        :param msg: The message that contains the username mention
        """
        verses = find_verses(msg.body)
        if verses is not None:
            response = Response(msg, self.parser)
            for verse in verses:
                book_name = books.get_book(verse[0])
                if book_name is not None:
                    v = Verse(book_name,                   # Book
                              verse[1],                    # Chapter
                              verse[3],                    # Translation
                              msg.author,                  # User
                              msg.subreddit.display_name,  # Subreddit
                              verse[2])                    # Verse
                    if not response.is_duplicate_verse(v):
                        response.add_verse(v)
            if len(response.verse_list) != 0:
                message_response = response.construct_message()
                if message_response is not None:
                    self.log.info("Replying to %s with verse quotations..."
                                  % msg.author)
                    try:
                        msg.reply(message_response)
                        database.update_db_stats(response.verse_list)
                        database.increment_comment_count()
                    except praw.errors.Forbidden:
                        # This message is unreachable.
                        pass
                    except praw.errors.APIException as err:
                        if err.error_type in ("TOO_OLD", "DELETED_LINK",
                                              "DELETED_COMMENT"):
                            self.log.warning("An error occurred while replying"
                                             " with error_type %s."
                                             % err.error_type)
        else:
            self.log.info("No verses found in this message. "
                          "Forwarding to /u/%s..." % VERSEBOT_ADMIN)
            try:
                self.r.send_message(VERSEBOT_ADMIN,
                                    "Forwarded VerseBot Message",
                                    "%s\n\n[[Link to Original Message](%s)]"
                                    % (msg.body, msg.permalink))
            except requests.ConnectionError:
                pass

def execute(message):
    chat = message['chat']
    chat_id = chat['id']

    text = message['text']
    if text.startswith('/test'):
        text = text.lstrip('/test')
        voice_prob = 0.2
        resp = Response(mood=Mood.NEUTRAL, voice_probability=voice_prob)
        resp.add_msg_or_voice(text)
        main.send_to_group(resp)
    else:
        main.send_response(str(chat_id), responder.reply_to(message))

def getToast():
	toast_id = int(request.args.get('toastId'))
	item = Toast.query.get(toast_id)
	if item is not None:
		res = {	
				"toast_id":item.id,
				"body":item.body, 
				"time":item.creation_time.strftime("%Y-%m-%d %H:%M:%S"), 
				"trumpet_count":item.trumpet_count,
				"shit_count":item.shit_count
			}
		return jsonify(Response.success(msg="拉取成功", data=res))
	else:
		return jsonify(Response.fail(msg="找不到这条toast"))

def insertInfo():
	name = request.args.get('name')
	phone = request.args.get('phone')
	position = request.args.get('position')
	if phone is None or len(phone.strip())<1 or not phone.isdigit():
		return jsonify(Response.fail(msg="信息有误"))
	items = Scanner.query.filter_by(phone=phone).all()
	if len(items)>0:
		return jsonify(Response.fail(msg="该手机号已录入，请更换手机号"))
	else:
		scanner = Scanner(name, phone, position)
		db.session.add(scanner)
		db.session.commit()
		return jsonify(Response.success(msg="插入成功", data=scanner.id))

def shit():
	toast_id = int(request.args.get('toastId'))
	uid = int(request.args.get('uid'))
	shit_operation = ToastOperation(uid, toast_id, SHIT_OPERATION, datetime.now())
	db.session.add(shit_operation)
	db.session.commit()
	# 让记录+1
	toast = Toast.query.get(toast_id)
	if toast is not None:
		toast.shit_count += 1
		db.session.commit()
	else:
		return jsonify(Response.fail(msg="找不到这条toast"))
	return jsonify(Response.success(msg="shit成功"))

def trailing_volatility(ticker, components):
	days=None
	for each in components: 
		if PATTERNS['tvol'].match(each):
			days = int(each)
			break
	if days==None:
		return {"message": Response.trailing_days(ticker)}
	try:
		quotes = data.DataReader(ticker, 'google')['Close'][-days:]
	except Exception:
		return {"message": Response.data_notfound(ticker)}
	logreturns = np.log(quotes / quotes.shift(1))
	vol = round(np.sqrt(252*logreturns.var()), 5)
	return {"message" : Response.trailing_vol(days, ticker, vol)}

def toast():
	uid = request.args.get('uid')
	body = request.args.get('body')
	toast = Toast(uid, body, datetime.now(), 0, 0)
	db.session.add(toast)
	db.session.commit()
	return jsonify(Response.success(msg="吐槽成功"))

def list_toasts():
	page = int(request.args.get('page'))
	uid = int(request.args.get('uid'))
	paginate = Toast.query.order_by(Toast.creation_time.desc()).paginate(page, ITEMS_PER_PAGE, False)
	toast_list = paginate.items
	res = []
	for item in toast_list:
		item_res = {	
						"toast_id":item.id,
						"body":item.body, 
						"time":item.creation_time.strftime("%Y-%m-%d %H:%M:%S"), 
						"trumpet_count":item.trumpet_count,
						"shit_count":item.shit_count,
						"trumpet":0,
						"shit":0
					}

		toast_operation_list = ToastOperation.query.filter_by(uid=uid).filter_by(toast_id=item.id).all()
		for operation in toast_operation_list:
			if operation.type == 0:
				item_res['shit'] = 1
			if operation.type == 1:
				item_res['trumpet'] = 1

		res.append(item_res)
	return jsonify(Response.success(msg="拉取成功", data=res))

 def logout_client(self, current_page, request):
     client_name = request.parameters['name']
     if self.manager.logout(client_name):
         response = Response.create_login()
     else:
         response = Response(page=current_page)
     return response