def admin(self):
     selection = list(r.db(RDB['ticketsdb']).table('tickets').order_by(r.desc(lambda date: date['meta']['updated_at'])).run(g.rdb_conn))
     if selection is not None:
         print(selection)
         return render_template('tickets/ticketslist.html', results=selection)
     else:
         return "Not Found", 404

    def load_ebook(self, ebook_id):
        # query returns dict with ebook->versions->formats nested document
        # versions are ordered by popularity
        try:
            ebook = (
                r.table("ebooks")
                .get(ebook_id)
                .merge(
                    lambda ebook: {
                        "versions": r.table("versions")
                        .get_all(ebook["ebook_id"], index="ebook_id")
                        .order_by(r.desc("ranking"))
                        .coerce_to("array")
                        .merge(
                            lambda version: {
                                "formats": r.table("formats")
                                .get_all(version["version_id"], index="version_id")
                                .coerce_to("array")
                            }
                        )
                    }
                )
                .run()
            )

        except RqlRuntimeError as e:
            if "Cannot perform merge on a non-object non-sequence `null`" in str(e):
                return None
            else:
                raise e

        return ebook

def get_messages():
    conn = r.connect(host='localhost',
                     port=28015,
                     db='chatrethink')
    messages = r.table('messages').order_by(r.desc('added')).limit(25).run(conn)
    messages = [{'text': message['text'], 'username': message['by']} for message in reversed(list(messages))]
    return jsonify({'messages': messages})

    def get(self):

        conn = yield self.rethinkdb_conn

        posts = yield r.table("posts")\
            .order_by(index=r.desc("created_time"))\
            .pluck(
                {"images":{"low_resolution":{"url":True}}},
                {"user":{"username":True}},
                "created_time",
                "link",
                {"caption":{"text":True}})\
            .limit(9)\
            .run(conn)

        output_posts = []
        while(yield posts.fetch_next()):

            if len(output_posts) >= 9:
                break;

            p = yield posts.next()
            output_posts.append(p)

        home_template = template_env.get_template("home.html")

        subscriptions_raw = insta_api.list_subscriptions()
        subscriptions = [x['object_id'] for x in subscriptions_raw['data']]

        self.write(home_template.render(
            auth_url = insta_api.get_authorize_url(),
            posts = output_posts,
            subscriptions = subscriptions
            ))

 def get_peak_records(self, account_year_pairs):
     return self.uow.run_list(self.table.get_all(*account_year_pairs, index='peak_report')
                              .map(lambda record: {'account_id': record['account_id'],
                                                   'readingdateutc': record['readingdateutc'],
                                                   'demand': record['energy']['demand'],
                                                   'weather': record['weather']})
                              .order_by(r.desc('demand')).limit(50))

def list_notes(hostname):
    """Retrieve a list of notes associated with a host. Or given
      {'user': 'username', 'note': 'some message'} post a note."""
    if request.method == 'GET':
        try:
            #someday i should probably add offset support here and in the statelog
            limit = request.args.get('limit', 50, type=int)
        except ValueError:
            abort(400)
        notes = list(r.table("notes").filter({"hostname": hostname}).order_by(r.desc("ts")).limit(limit).run(rdb.conn))
        if notes:
            return jsonify({'notes': sorted(notes, key=lambda k: k['ts'])})
        else:
            abort(404)
    elif request.method == 'POST':
        if not request.json:
            abort(400)
        if not request.json.get("user") or not request.json.get("note"):
            abort(400)
        if not r.table("hosts").get_all(hostname, index="hostname").run(rdb.conn):
            abort(404)
        alerting = [x["check"] for x in r.table("checks").filter({"h stname": hostname, "status": False}).run(rdb.conn)]
        q = r.table("notes").insert({'hostname': hostname, 'user': request.json.get("user"),
                                     'note': request.json.get("note"), 'ts': time(), 'alerting': alerting}).run(rdb.conn)
        if q["inserted"] == 1:
            return jsonify({'success': True})
        else:
            logger.error(q)
            abort(500)
    else:
        abort(400)

 def history(
     self, method=None, hid=None,
         time=None, start=None, limit=None, rdb=None):
     ''' This will pull a monitors history from rethinkDB '''
     retdata = False
     if method == "mon-history":
         retdata = []
         monitors = r.table('history').filter(
             (r.row['cid'] == self.cid) & (r.row['starttime'] >= time) & (r.row['type'] == "monitor")).order_by(
             r.desc('starttime')).pluck('starttime', 'id', 'cid', 'zone', 'status', 'failcount', 'method', 'name').skip(start).limit(limit).run(rdb)
         for mon in monitors:
             mon['starttime'] = datetime.datetime.fromtimestamp(
                 mon['starttime']).strftime('%Y-%m-%d %H:%M:%S')
             retdata.append(mon)
     elif method == "detail-history":
         retdata = []
         mon = r.table('history').get(hid).pluck(
             'starttime', 'cid', 'zone', 'status',
             'failcount', 'method', 'name').run(rdb)
         mon['reactions'] = []
         reactions = r.table('history').filter(
             (r.row['cid'] == self.cid) & (r.row['starttime'] == mon['starttime']) & (r.row['zone'] == mon['zone']) & (r.row['type'] == "reaction")).pluck('name', 'rstatus', 'time', 'starttime').run(rdb)
         for react in reactions:
             react['starttime'] = datetime.datetime.fromtimestamp(
                 react['starttime']).strftime('%Y-%m-%d %H:%M:%S')
             react['time'] = datetime.datetime.fromtimestamp(
                 react['time']).strftime('%Y-%m-%d %H:%M:%S')
             mon['reactions'].append(react)
         mon['starttime'] = datetime.datetime.fromtimestamp(
             mon['starttime']).strftime('%Y-%m-%d %H:%M:%S')
         retdata.append(mon)
     elif method == "count":
         retdata = r.table('history').filter(
             (r.row['cid'] == self.cid) & (r.row['starttime'] >= time) & (r.row['type'] == "monitor")).count().run(rdb)
     return retdata

def renderScores(nameOfTable, GameName):
    r.connect().repl()

    try:
        r.db("test").table_create(nameOfTable).run()
    except r.ReqlOpFailedError:
        pass

    bestScorePerPlayer = r.table(nameOfTable).group("username").max("score").run()
    topscoresPerPlayer = r.expr(bestScorePerPlayer.values()).order_by(r.desc("score")).limit(10).run()
    topscoresofalltime = r.table(nameOfTable).order_by(r.desc("score")).limit(10).run()
    
    tabifyResult(topscoresPerPlayer)
    tabifyResult(topscoresofalltime)
    
    return render_template('bshighScores.html',gameName=GameName, topscoresByPlayerTable=topscoresPerPlayer,topscoresalltimeTable=topscoresofalltime)

 def get_latest_with_keyword(cls, search_keyword):
     # Looks like we can't chain a get_all with an order_by, so we can't use
     # the search_keyword index.
     query = (r.table(cls._TABLE_NAME)
             .order_by(index=r.desc('pushed_at'))
             .filter({'search_keyword': search_keyword}))
     return db.util.get_first(query)

 def get_all(self):
     selection = list(r.db(rdb['chatdb']).table('chats').order_by(r.desc(lambda date: date['meta']['updated_at'])).run(g.rdb_conn))
     if selection is not None:
         print("Chat.get_all: Retrieved Chat messages from DB: {}".format(selection))
         return render_template('chat/chatlist.html', results=selection)
     else:
         return "Not Found", 404

 def players_by_score(cls):
     watershed = datetime.datetime.now() - datetime.timedelta(minutes=1)
     players = cls.query(
         rdb.row['beat'] > pytz.utc.localize(watershed)
     ).order_by(
         rdb.desc('score')
     ).fetch()
     return players

def latest():
    last_report = r.table(STATS_TABLE).order_by(r.desc('datetime'))[0]
    selection = last_report['by_milestone'].filter(lambda report_by_m:
            is_in_array(report_by_m['milestone'], MILESTONES)
        ).map(lambda filtered_report: 
            filtered_report.merge({'datetime': last_report['datetime']})
        ).run(g.rdb_conn)
    return json.dumps(selection)

 def on_get(self, req, resp):
     filter = (req.get_param('filter') or 'launched').capitalize()
     limit = req.get_param_as_int('limit') or 1
     projects = r.table('projectsRecently%s' % filter) \
         .order_by(r.desc('launched_at')) \
         .limit(limit) \
         .run(self.connection)
     resp.body = json.dumps(projects)

 def test_sort_1_attr_2_desc(self, conn):
     expected = [
         {'id': 'bill', 'age': 35, 'score': 78},
         {'id': 'joe', 'age': 26, 'score': 60},
         {'id': 'todd', 'age': 52, 'score': 15},
     ]
     result = r.db('y').table('scores').order_by(r.desc('score')).run(conn)
     assertEqual(expected, list(result))

def languages_db():
    """Get the languages stored in the database"""
    s_langs = r.db("indielangs").table("languages").order_by(r.desc("timestamp")).limit(1).run(DB)

    if len(s_langs) != 0:
        return s_langs[0]
    else:
        return {}

def select():
    try:
        rdb_conn = rdb.connect(host=RDB_HOST, port=RDB_PORT, db=DB_NAME)
        result = rdb.db(DB_NAME).table(TABLE_NAME).order_by(index=rdb.desc('point')).limit(10).run(rdb_conn)
        rdb_conn.close()
        return result
    except RqlDriverError:
        abort(503, "No database connection could be established.")

def get_all_hypervisor_status(hyp_id, start=None, end=None):
    r_conn = new_rethink_connection()
    rtable = r.table('hypervisors_status')
    if start and end:
        results = rtable.filter({'hyp_id': hyp_id}).filter(lambda s: start <= s['when'] and s['when'] <= end).order_by(
            r.desc('when')).run(r_conn)
    elif start:
        results = rtable.filter({'hyp_id': hyp_id}).filter(lambda s: start <= s['when']).order_by(r.desc('when')).run(
            r_conn)
    elif end:
        results = rtable.filter({'hyp_id': hyp_id}).filter(lambda s: s['when'] <= end).order_by(r.desc('when')).run(
            r_conn)
    else:
        results = rtable.filter({'hyp_id': hyp_id}).order_by(r.desc('when')).run(r_conn)
    results = list(results)
    close_rethink_connection(r_conn)
    return results

def get_index():
    conn = r.connect()
    quakes = list(r.table("quakes")
      .order_by(r.desc(r.row["properties"]["mag"]))
      .limit(10).run(conn))
    conn.close()

    return flask.render_template("quakes.html", quakes=quakes)

 def get(self, ds_id):
     dataset = r.table('datasets').get(ds_id).run(db.conn)
     dataset = chocapic(dataset)
     visualizations = list(r.table('visualizations').filter(
         {'dataset_id': ds_id}).order_by(r.desc('added_at')).run(db.conn))
     visualizations = cornflakes(visualizations)
     return render_template('datasets/get.html',
         dataset=dataset, visualizations=visualizations)

    def claim_sites(self, n=1):
        self.logger.trace('claiming up to %s sites to brozzle', n)
        result = (
            self.rr.table('sites').get_all(r.args(
                r.db(self.rr.dbname).table('sites', read_mode='majority')
                .between(
                    ['ACTIVE', r.minval], ['ACTIVE', r.maxval],
                    index='sites_last_disclaimed')
                .order_by(r.desc('claimed'), 'last_disclaimed')
                .fold(
                    {}, lambda acc, site: acc.merge(
                        r.branch(
                            site.has_fields('job_id'),
                            r.object(
                                site['job_id'].coerce_to('string'),
                                acc[site['job_id'].coerce_to('string')].default(0).add(1)),
                            {})),
                    emit=lambda acc, site, new_acc: r.branch(
                        r.and_(
                            r.or_(
                                site['claimed'].not_(),
                                site['last_claimed'].lt(r.now().sub(60*60))),
                            r.or_(
                                site.has_fields('max_claimed_sites').not_(),
                                new_acc[site['job_id'].coerce_to('string')].le(site['max_claimed_sites']))),
                            [site['id']], []))
                .limit(n)))
            .update(
                # try to avoid a race condition resulting in multiple
                # brozzler-workers claiming the same site
                # see https://github.com/rethinkdb/rethinkdb/issues/3235#issuecomment-60283038
                r.branch(
                    r.or_(
                      r.row['claimed'].not_(),
                      r.row['last_claimed'].lt(r.now().sub(60*60))),
                    {'claimed': True, 'last_claimed': r.now()},
                    {}),
                return_changes=True)).run()

        self._vet_result(
                result, replaced=list(range(n+1)),
                unchanged=list(range(n+1)))
        sites = []
        for i in range(result["replaced"]):
            if result["changes"][i]["old_val"]["claimed"]:
                self.logger.warn(
                        "re-claimed site that was still marked 'claimed' "
                        "because it was last claimed a long time ago "
                        "at %s, and presumably some error stopped it from "
                        "being disclaimed",
                        result["changes"][i]["old_val"]["last_claimed"])
            site = brozzler.Site(self.rr, result["changes"][i]["new_val"])
            sites.append(site)
        self.logger.debug('claimed %s sites', len(sites))
        if sites:
            return sites
        else:
            raise brozzler.NothingToClaim