def update_timeline():
    i = ctx.request.input()
    client = _create_client()
    data = client.parse_signed_request(i.signed_request)
    if data is None:
        raise StandardError('Error!')
    user_id = data.get('uid', '')
    auth_token = data.get('oauth_token', '')
    if not user_id or not auth_token:
        return dict(error='bad_signature')
    expires = data.expires
    client.set_access_token(auth_token, expires)

    u = db.select('select since_id from users where id=?', user_id)[0]
    kw = dict(uid=user_id, count=100, trim_user=1)
    since_id = u.since_id
    if since_id:
        kw['since_id'] = since_id

    timeline = client.statuses.user_timeline.get(**kw)
    statuses = timeline.statuses
    count = 0
    if statuses:
        since_id = str(statuses[0].id)
        for st in statuses:
            info = record.parse(st.text)
            if info:
                t, ymd = _parse_datetime(st.created_at)
                r = dict(id=st.id, user_id=user_id, text=st.text, created_at=t, rdistance=info[0], rtime=info[1], rdate=ymd)
                if not db.select('select id from records where id=?', st.id):
                    db.insert('records', **r)
                    count = count + 1
        db.update_kw('users', 'id=?', user_id, since_id = since_id)
    return dict(count=count, since_id=since_id)

def get_settings(kind=None, remove_prefix=False):
    '''
    Get all settings.
    '''
    settings = dict()
    if kind:
        L = db.select('select name, value from settings where kind=?', kind)
    else:
        L = db.select('select name, value from settings')
    for s in L:
        key = s.name[s.name.find('_')+1:] if remove_prefix else s.name
        settings[key] = s.value
    return settings

def _init_theme(path, model):
    theme = get_active_theme()
    model['__theme_path__'] = '/themes/%s' % theme
    model['__get_theme_path__'] = lambda _templpath: 'themes/%s/%s' % (theme, _templpath)
    model['__menus__'] = db.select('select * from menus order by display_order, name')
    model.update(get_settings('site'))
    if not 'site_name' in model:
        model['site_name'] = 'iTranswarp'
    if not '__title__' in model:
        model['__title__'] = model['site_name']
    model['ctx'] = ctx
    model['__layout_categories__'] = db.select('select * from categories order by display_order, name')
    return 'themes/%s/%s' % (theme, path), model

def get_default_cv(uid):
    cvs = None
    while not cvs:
        cvs = db.select('select * from resumes where user_id=?', uid)
        if not cvs:
            cv_id = db.next_str()
            db.insert('resumes', id=cv_id, user_id=uid, title='My Resume', version=0)
            db.insert('sections', id=db.next_str(), user_id=uid, resume_id=cv_id, display_order=0, kind='about', title='About', description='', version=0)

    cv = cvs[0]
    cv.sections = db.select('select * from sections where resume_id=? order by display_order', cv.id)
    for section in cv.sections:
        section.style = _SECTIONS_STYLE[section.kind]
        section.entries = db.select('select * from entries where section_id=? order by display_order', section.id)
    return cv

def featured_poems():
    total = db.select_int('select count(id) as num from poem where ilike>=100')
    s = set()
    while len(s)<5:
        s.add(random.randint(0, total-1))
    L = []
    for n in s:
        L.extend(db.select('select * from poem where ilike>=100 order by id limit ?,?', n, 1))
    total = db.select_int('select count(id) from poem where ilike<100')
    s = set()
    while len(s)<5:
        s.add(random.randint(0, total-1))
    for n in s:
        L.extend(db.select('select * from poem where ilike<100 order by id limit ?,?', n, 1))
    return dict(poems=L)

def callback():
    i = ctx.request.input(code="")
    code = i.code
    client = _create_client()
    r = client.request_access_token(code)
    logging.info("access token: %s" % json.dumps(r))
    access_token, expires_in, uid = r.access_token, r.expires_in, r.uid
    client.set_access_token(access_token, expires_in)
    u = client.users.show.get(uid=uid)
    logging.info("got user: %s" % uid)
    users = db.select("select * from users where id=?", uid)
    user = dict(
        name=u.screen_name,
        image_url=u.avatar_large or u.profile_image_url,
        statuses_count=u.statuses_count,
        friends_count=u.friends_count,
        followers_count=u.followers_count,
        verified=u.verified,
        verified_type=u.verified_type,
        auth_token=access_token,
        expired_time=expires_in,
    )
    if users:
        db.update_kw("users", "id=?", uid, **user)
    else:
        user["id"] = uid
        db.insert("users", **user)
    _make_cookie(uid, access_token, expires_in)
    raise seeother("/")

def get_comments_desc(ref_id, max_results=20, after_id=None):
    '''
    Get comments by page.

    Args:
        ref_id: reference id.
        max_results: the max results.
        after_id: comments after id.
    Returns:
        comments as list.
    '''
    if max_results < 1 or max_results > 100:
        raise ValueError('bad max_results')
    if after_id:
        return db.select('select * from comments where ref_id=? and id < ? order by id desc limit ?', ref_id, after_id, max_results)
    return db.select('select * from comments where ref_id=? order by id desc limit ?', ref_id, max_results)

def callback():
    i = ctx.request.input(code='')
    code = i.code
    client = _create_client()
    r = client.request_access_token(code)
    logging.info('access token: %s' % json.dumps(r))
    access_token, expires_in, uid = r.access_token, r.expires_in, r.uid
    client.set_access_token(access_token, expires_in)
    u = client.users.show.get(uid=uid)
    logging.info('got user: %s' % uid)
    users = db.select('select * from users where id=?', uid)
    user = dict(name=u.screen_name, \
            image_url=u.avatar_large or u.profile_image_url, \
            statuses_count=u.statuses_count, \
            friends_count=u.friends_count, \
            followers_count=u.followers_count, \
            verified=u.verified, \
            verified_type=u.verified_type, \
            auth_token=access_token, \
            expired_time=expires_in)
    if users:
        db.update_kw('users', 'id=?', uid, **user)
    else:
        user['id'] = uid
        db.insert('users', **user)
    _make_cookie(uid, access_token, expires_in)
    raise seeother('/')

	def find_by(cls, where, *args):
   		'''
   		Find by where clause and return list.
   		'''
   		sql = 'select * from %s where %s' % (cls.__table__, where)

   		d = db.select(sql, *args)
   		return [cls(**i) for l in d]

def _get_site(host):
    wss = db.select('select * from websites where domain=?', host)
    if wss:
        ws = wss[0]
        if ws.disabled:
            logging.debug('website is disabled: %s' % host)
            raise forbidden()
        return ws
    raise notfound()

def _load_app_info():
    global _APP_ID, _APP_SECRET, _ADMIN_PASS
    for s in db.select("select * from settings"):
        if s.id == "app_id":
            _APP_ID = s.value
        if s.id == "app_secret":
            _APP_SECRET = s.value
        if s.id == "admin_pass":
            _ADMIN_PASS = s.value

def archives():
    years = db.select('select distinct `year` from `blogs` order by created desc')
    if not years:
        raise notfound()
    xblogs = list()
    for y in years:
        blogs = Blogs.find_by('where `year` = ? order by created desc', y.get('year'))
        xblogs.append(blogs)
    return dict(xblogs=xblogs)

def dynasty_page(dyn_id):
    '''
    GET /dynasty/{dynasty_id}/{page}
    
    Show dynasty page.
    '''
    dynasty = get_dynasty(dyn_id)
    dynasties = get_dynasties()
    poets = db.select('select * from poet where dynasty_id=? order by pinyin', dyn_id)
    return dict(title=dynasty.name, dynasty=dynasty, dynasties=dynasties, poets=poets)

def get_text(name, default=''):
    '''
    Get text by name. Return default value '' if not exist.
    '''
    ss = db.select('select value from texts where name=?', name)
    if ss:
        v = ss[0].value
        if v:
            return v
    return default

def get_menus():
    '''
    Get navigation menus as list, each element is a Dict object.
    '''
    menus = db.select('select * from menus order by display_order, name')
    if menus:
        return menus
    current = time.time()
    menu = Dict(id=db.next_str(), name=u'Home', description=u'', type='latest_articles', display_order=0, ref='', url='/latest', creation_time=current, modified_time=current, version=0)
    db.insert('menus', **menu)
    return [menu]

def _get_Text(username):
    lb = db.select('select * from labels where username=? and weight>0', username)
    txt = []
    wei = []

    for i in range(0, len(lb)):
        print lb[i]['label']
        txt.append(lb[i]['label'])
        wei.append(lb[i]['weight'])

    return {"text": txt, "weight":wei }

def get_poems(poet_id, page=1):
    '''
    Return poems of page N (N=1, 2, 3) and has_next.
    '''
    if page < 1 or page > 100:
        raise ValueError('invalid page.')
    offset = PAGE_SIZE * (page - 1)
    maximum = PAGE_SIZE + 1
    L = db.select('select * from poem where poet_id=? order by name_pinyin limit ?,?', poet_id, offset, maximum)
    if len(L) == maximum:
        return L[:-1], True
    return L, False

def archives():
    sql = 'SELECT YEAR(`created`) AS `year`, `id`, `title`, `created` FROM `blogs` ORDER BY `created` DESC'
    blogs = db.select(sql)
    if not blogs:
        raise notfound()
    xblogs = OrderedDict()
    for blog in blogs:
        if not blog['year'] in xblogs:
            xblogs[blog['year']] = [blog]
        else:
            xblogs[blog['year']].append(blog)
    return dict(xblogs=xblogs)

def getUsers():
    u = _check_cookie()
    if u is None:
        return dict(error='failed', redirect='/signin')
    client = _create_client()
    client.set_access_token(u.auth_token, u.expired_time)
    try:
        output = db.select('select * from users')
        result = {'users':output}
        return result
    except APIError, e:
        return dict(error='failed')

def _get_Image(label, username):
    li = db.select('select id from labels where label=? and username=?', label, username)

    print li

    imgs = db.select('select * from pictures where labelID=?', li[0]['id'])
    src = []
    dec = []

    for i in range(0, len(imgs)):
        full = imgs[i]['picUrl']
        tm = imgs[i]['upTime']

        cn = re.findall('[a-z0-9A-Z]+.jpg', full)
        full = cn[0]

        tm = tm[4:10] + tm[25:30]

        src.append(full)
        dec.append(tm)

    return {"src": src, "dec": dec}