def POST(self):
        inp = web.input(close_after=False, item_host=None, item_path=None, item_name=None, content=None, item_user=None)

        model.new_comment(session.user.name, inp.item_host, inp.item_path, inp.item_name, inp.content, inp.item_user)

        page_owner = model.get_user(name=inp.item_user)
        if page_owner.mailmode == "all":
            web.sendmail(
                'Comment on This! <[email protected]>',
                page_owner.email,
                '[CoT] New comment on '+get_domain(inp.item_host),
                session.user.name+" posted a comment on "+inp.item_host+inp.item_path+"#"+inp.item_name+":"+
                "\n\n"+inp.content+
                "\n\n    -- The Comment on This Team"
            )

        if inp.close_after:
            return render.comment_thanks()
        else:
            raise web.seeother(
                "/comment"+
                "?item_host="+web.urlquote(inp.item_host)+
                "&item_path="+web.urlquote(inp.item_path)+
                "&item_name="+web.urlquote(inp.item_name)
            )

def uuap_sso():
    sso_username = web.config.session.get('sso_username')
    #如果有已经登陆则返回用户名，否则跳转到uuap登录页
    if sso_username:
        logging.debug('sso_username: %s' % sso_username)
        return sso_username
    service_url = '%s/zmon/auth?u=%s' % (web.ctx.homedomain, web.urlquote(web.ctx.homepath + web.ctx.fullpath))
    raise web.seeother('%s/login?service=%s' % (SSO_URL, web.urlquote(service_url)))

 def GET(self):
     user_data = web.input(u=None, ticket=None)
     if not user_data.u or not user_data.ticket:
         return render.forbidden(userName)
     service_url = '%s/sso?u=%s' % (web.ctx.homedomain, web.urlquote(user_data.u))
     validate_url = '%s/validate?service=%s&ticket=%s' % (SSO_URL, web.urlquote(service_url), web.urlquote(user_data.ticket))
     r = urllib.urlopen(validate_url).readlines()
     if len(r) == 2 and r[0].strip() == 'yes':
         web.config.session.sso_username = r[1].strip()
         raise web.seeother(user_data.u)
     else:
         return render.forbidden(userName)

    def POST(self):
        i = web.input(_unicode=False, mail=[])

        self.mails = i.get('mail', [])
        self.action = i.get('action', None)
        msg = i.get('msg', None)

        adminLib = adminlib.Admin()

        if self.action == 'delete':
            result = adminLib.delete(mails=self.mails,)
            msg = 'DELETED'
        elif self.action == 'disable':
            result = adminLib.enableOrDisableAccount(accounts=self.mails, active=False,)
            msg = 'DISABLED'
        elif self.action == 'enable':
            result = adminLib.enableOrDisableAccount(accounts=self.mails, active=True,)
            msg = 'ENABLED'
        else:
            result = (False, 'INVALID_ACTION')

        if result[0] is True:
            raise web.seeother('/admins?msg=%s' % msg)
        else:
            raise web.seeother('/admins?msg=?' + web.urlquote(result[1]))

    def POST(self, domain):
        i = web.input(_unicode=False, mail=[])
        self.domain = web.safestr(domain)
        self.mails = i.get('mail', [])
        self.action = i.get('action', None)

        userLib = user.User()

        if self.action == 'delete':
            result = userLib.delete(domain=self.domain, mails=self.mails,)
            msg = 'DELETED'
        elif self.action == 'disable':
            result = userLib.enableOrDisableAccount(domain=self.domain, mails=self.mails, action='disable',)
            msg = 'DISABLED'
        elif self.action == 'enable':
            result = userLib.enableOrDisableAccount(domain=self.domain, mails=self.mails, action='enable',)
            msg = 'ENABLED'
        else:
            result = (False, 'INVALID_ACTION')
            msg = i.get('msg', None)

        if result[0] is True:
            cur_page = i.get('cur_page', '1')
            raise web.seeother('/users/%s/page/%s?msg=%s' % (self.domain, str(cur_page), msg, ))
        else:
            raise web.seeother('/users/%s?msg=%s' % (self.domain, web.urlquote(result[1])))

    def GET(self, profile_type, domain):
        i = web.input()
        self.domain = web.safestr(domain.split('/', 1)[0])
        self.profile_type = web.safestr(profile_type)

        if not iredutils.is_domain(self.domain):
            raise web.seeother('/domains?msg=EMPTY_DOMAIN')

        domainLib = domainlib.Domain()
        result = domainLib.profile(domain=self.domain)

        if result[0] is False:
            raise web.seeother('/domains?msg=' + web.urlquote(result[1]))

        r = domainLib.listAccounts(attrs=['domainName'])
        if r[0] is True:
            allDomains = r[1]
        else:
            return r

        allAccountSettings = ldaputils.getAccountSettingFromLdapQueryResult(result[1], key='domainName',)

        return web.render(
            'ldap/domain/profile.html',
            cur_domain=self.domain,
            allDomains=allDomains,
            allAccountSettings=allAccountSettings,
            profile=result[1],
            profile_type=self.profile_type,
            msg=i.get('msg', None),
        )

def login_hook(handler):
    path_info = web.ctx.env['PATH_INFO']
    if path_info != '/login' and not session.login:
        uri = web.ctx.env['REQUEST_URI']
        web.seeother('/login?return_url=' + web.urlquote(uri))
    else:
        return handler()

    def get_results(self, q, offset=0, limit=100):
        if config.get('single_core_solr'):            
            valid_fields = ['key', 'name', 'subject_type', 'work_count']
        else:
            valid_fields = ['key', 'name', 'type', 'count']

        q = escape_colon(escape_bracket(q), valid_fields)
        params = {
            "q.op": "AND",
            "q": web.urlquote(q),
            "start": offset,
            "rows": limit,
            "fl": ",".join(valid_fields),
            "qt": "standard",
            "wt": "json"
        }
        if config.get('single_core_solr'):
            params['fq'] = 'type:subject'
            params['sort'] = 'work_count desc'
        else:                
            params['sort'] = 'count desc'

        solr_select = solr_subject_select_url + "?" + urllib.urlencode(params)
        results = run_solr_search(solr_select)
        response = results['response']

        if config.get('single_core_solr'):
            response['docs'] = [self.process_doc(doc) for doc in response['docs']]

        return results

 def get_results(q, offset=0, limit=100, snippets=3, fragsize=200, hl_phrase=False):
     m = re_bad_fields.match(q)
     if m:
         return { 'error': m.group(1) + ' search not supported' }
     q = escape_q(q)
     solr_params = [
         ('fl', 'ia,body_length,page_count'),
         ('hl', 'true'),
         ('hl.fl', 'body'),
         ('hl.snippets', snippets),
         ('hl.mergeContiguous', 'true'),
         ('hl.usePhraseHighlighter', 'true' if hl_phrase else 'false'),
         ('hl.simple.pre', '{{{'),
         ('hl.simple.post', '}}}'),
         ('hl.fragsize', fragsize),
         ('q.op', 'AND'),
         ('q', web.urlquote(q)),
         ('start', offset),
         ('rows', limit),
         ('qf', 'body'),
         ('qt', 'standard'),
         ('hl.maxAnalyzedChars', '-1'),
         ('wt', 'json'),
     ]
     solr_select = solr_select_url + '?' + '&'.join("%s=%s" % (k, unicode(v)) for k, v in solr_params)
     stats.begin("solr", url=solr_select)
     json_data = urllib.urlopen(solr_select).read()
     stats.end()
     try:
         return simplejson.loads(json_data)
     except:
         m = re_query_parser_error.search(json_data)
         return { 'error': web.htmlunquote(m.group(1)) }

    def GET(self, domain, cur_page=1):
        self.domain = web.safestr(domain).split('/', 1)[0]
        cur_page = int(cur_page)

        if not iredutils.is_domain(self.domain):
            raise web.seeother('/domains?msg=INVALID_DOMAIN_NAME')

        if cur_page == 0:
            cur_page = 1

        userLib = userlib.User()
        result = userLib.listAccounts(domain=self.domain, cur_page=cur_page,)
        if result[0] is True:
            (total, records) = (result[1], result[2])

            return web.render(
                'pgsql/user/list.html',
                cur_domain=self.domain,
                cur_page=cur_page,
                total=total,
                users=records,
                msg=web.input().get('msg', None),
            )
        else:
            raise web.seeother('/domains?msg=%s' % web.urlquote(result[1]))

    def POST(self):
        i = web.input(domainName=[], _unicode=False,)

        self.domainName = i.get('domainName', [])
        self.action = i.get('action', None)

        domainLib = domainlib.Domain()

        if self.action == 'delete':
            result = domainLib.delete(domains=self.domainName)
            msg = 'DELETED'
        elif self.action == 'disable':
            result = domainLib.enableOrDisableAccount(domains=self.domainName, action='disable',)
            msg = 'DISABLED'
        elif self.action == 'enable':
            result = domainLib.enableOrDisableAccount(domains=self.domainName, action='enable',)
            msg = 'ENABLED'
        else:
            result = (False, 'INVALID_ACTION')
            msg = i.get('msg', None)

        if result[0] is True:
            raise web.seeother('/domains?msg=%s' % msg)
        else:
            raise web.seeother('/domains?msg=' + web.urlquote(result[1]))

	def render(self,renderObject):
		if 'frameview' == self.m_renderType or 'view' == self.m_renderType:
			if not self.view():
				self.buildView()
			
			# 在 json 请求中不需要此参数
			self.setVariable('urlPath',self.m_urlPath)
			self.setVariable('url',web.ctx.fullpath)
			self.setVariable('urlquote',web.urlquote( web.ctx.fullpath ) )
			
			if 'frameview' == self.m_renderType:
				return self.view().rootView().render(
					renderObject,
					self.m_variableDict
				)
			else:
				return self.view().render(
					renderObject,
					self.m_variableDict
				)
		elif 'json' == self.m_renderType:
			if self.__status == 'ok':
				self.setVariable('result',True)
			else:
				self.setVariable('result',False)
			return json.dumps(self.m_variableDict)
		else:
			return self.m_renderType

def simple_search(q, offset=0, rows=20, sort=None):
    solr_select = solr_select_url + "?version=2.2&q.op=AND&q=%s&fq=&start=%d&rows=%d&fl=*%%2Cscore&qt=standard&wt=json" % (web.urlquote(q), offset, rows)
    if sort:
        solr_select += "&sort=" + web.urlquote(sort)

    stats.begin("solr", url=solr_select)
    json_data = urllib.urlopen(solr_select)
    stats.end()
    return json.load(json_data)

	def GET(self):
		login_error = '登录失败，可能是服务器与新浪oauth服务交互出现问题，请稍候重试，<a href="/">返回</a>'

		i = web.input()
		if i.get('act') == 'auth':
			try:
				token, secret = login_auth.get_weibo_token()
			except:
				web.header('Content-Type', 'text/html; charset=utf-8')
				traceback.print_exc()
				return login_error
			session.token = token
			session.secret = secret
			if web.ctx.env['SERVER_PORT'] == '9527':
				oauth_callback = web.urlquote('http://localhost:9527/login?act=callback')
			else:
				oauth_callback = web.urlquote('http://gaoding.me/login?act=callback')

			raise web.seeother('http://api.t.sina.com.cn/oauth/authorize?oauth_token=%(token)s&oauth_callback=%(oauth_callback)s' % locals())
		elif i.get('act') == 'callback':
			'''
			http://localhost:8080/login?act=callback&oauth_token=e43e721b87c0b1c5fc9ad0746fcd1c0f&oauth_verifier=186264
			'''
			token = i.get('oauth_token')
			secret = session.get('secret')
			oauth_verifier = i.get('oauth_verifier')
			
			try:
				token, secret, user_id = login_auth.get_weibo_access_token(token, secret, oauth_verifier)
				user_info = login_auth.get_weibo_info(token, secret)
			except:
				traceback.print_exc()
				web.header('Content-Type', 'text/html; charset=utf-8')
				return login_error

			user_info = simplejson.loads(user_info)
			
			user = User()
			user.login('weibo', user_info)

			raise web.seeother('/')

		return 'Access denied'

	def process(self):
		i = web.input()
		
		if 'redirect' in i:
			redirect = i['redirect']
		else:
			redirect = '/'
		
		self.setVariable('redirect',redirect)
		self.setVariable('redirect_quote',web.urlquote( redirect ) )

def search_inside_result_count(q):
    q = escape_q(q)
    solr_select = solr_select_url + "?fl=ia&q.op=AND&wt=json&q=" + web.urlquote(q)
    stats.begin("solr", url=solr_select)
    json_data = urllib.urlopen(solr_select).read()
    stats.end()
    try:
        results = simplejson.loads(json_data)
    except:
        return None
    return results['response']['numFound']

def search_inside_result_count(q):
    q = escape_q(q)
    params = {
        'fl': 'ia',
        'q.op': 'AND',
        'q': web.urlquote(q)
    }
    results = inside_solr_select(params)
    if 'error' in results:
        return None

    return results['response']['numFound']

def get_all_ia():
    print 'c'
    q = {'source_records~': 'ia:*', 'type': '/type/edition'}
    limit = 10
    q['limit'] = limit
    q['offset'] = 0

    while True:
        url = base_url() + "/api/things?query=" + web.urlquote(json.dumps(q))
        ret = jsonload(url)['result']
        for i in ret:
            yield i
        if not ret:
            return
        q['offset'] += limit

def result_table(data, birth, death, order):
    html = ' %d results' % len(data)
    l = []
    def clean(i, default, field):
        if field not in i:
            return default
        if i[field] is None:
            return ''
        m = re_year.match(i[field])
        return m.group(1) if m else i[field]

    data = [
        {
            'key': i['key'],
            'name': i['name'],
            'birth': clean(i, birth, 'birth_date'),
            'death': clean(i, death, 'death_date'),
        } for i in data]

    base_url = web.htmlquote("?birth=%s&death=%s&order=" % (web.urlquote(birth), web.urlquote(death)))
    html += '<tr>'
    html += '<th><a href="' + base_url + 'name">Name</a></th>'
    if birth:
        html += '<th>birth</th>'
    else:
        html += '<th><a href="' + base_url + 'birth">birth</a></th>'
    if death:
        html += '<th>death</th>'
    else:
        html += '<th><a href="' + base_url + 'death">death</a></th>'
    html += '</tr>'
    if order:
        data = sorted(data, key=lambda i:i[order])
    for i in data:
        html += '<tr><td><a href="http://openlibrary.org%s">%s</td><td>%s</td><td>%s</td><tr>' % (i['key'], web.htmlquote(i['name']), i['birth'], i['death'])
    return '<table>' + html + '</table>'

 def GET(self, tags = None):
     if tags:
         tags = [tag.lower() for tag in tags.split('/')]
     else: 
         tags = []
         
     add_tag = web.input(addtag = None)['addtag']
     remove_tag = web.input(removetag = None)['removetag']
     page = int(web.input(page = 1)['page'])
     category = web.input(category = '')['category']
     
     if add_tag in tags  or len(tags)>= MAX_NUMBER_OF_TAGS_FILTERS:
         add_tag = None
     
     if add_tag:
         tags = tags + [tag.lower() for tag in add_tag.split()]
         if category:
             return web.redirect('/tag/%s?category=%s' % (web.urlquote('/'.join(tags)), category))
         else:
             return web.redirect('/tag/%s' % web.urlquote('/'.join(tags)))
     if remove_tag:
         tags.remove(remove_tag.lower())
         if category:
             return web.redirect('/tag/%s?category=%s' % (web.urlquote('/'.join(tags)), category))
         else:
             return web.redirect('/tag/%s' % web.urlquote('/'.join(tags)))
     
     posts_count = models.Post.get_posts_count(tags_filter = tags, category_filter= category)
     posts = models.Post.get_posts(page, limit = POSTS_PER_PAGE, offset = POSTS_PER_PAGE * (page - 1), tags_filter = tags, category_filter= category)
     
     return render_template(render.index(posts, 
                                         tags, 
                                         category, 
                                         pagination = utils.Pagination(posts_count, page, POSTS_PER_PAGE),
                                         is_user_admin = users.is_current_user_admin()),
                                         title = 'Home')