def process_task(task_processes_avail): for sem, min_priority, max_priority in task_processes_avail: log.debug('trying to acquire sem for min {} max {}'.format(min_priority, max_priority)) if sem.acquire(block=False): log.debug('acquired semaphore') db_task = utils.mongo_retry(lambda: get_db().tasks.find_one({'status': 'queued', 'start_after': {'$lte': datetime.now()}, 'priority': {'$gte': min_priority, '$lte': max_priority}}, sort=[('priority', pymongo.ASCENDING), ('start_after', pymongo.ASCENDING)])) if db_task is None: log.debug('no task to process, releasing sem') sem.release() log.debug('sem released') else: log.debug('found task to process') break else: log.debug('did not acquire semaphore') else: return False id = db_task['_id'] log.debug('trying to lock task') res = utils.mongo_retry(lambda: get_db().tasks.update({'_id': id, 'status': 'queued'}, {'$set': {'status': 'running', 'timeout_time': datetime.now() + timedelta(seconds=db_task['timeout'])}})) if res['n'] == 0: log.debug('another instance got the task first, releasing sem') # Another instance got to this task before us sem.release() log.debug('sem released') return True def process_db_task(): task = Task.from_db(db_task) log.info('processing task: {}'.format(task)) try: next_tasks = utils.ensure_list(utils.call_in_process(task.run, timeout=task.timeout.total_seconds())) except Exception: log.info('task {} failed: {}'.format(task, traceback.format_exc())) log.debug('running failure method') next_tasks = task_failed(task) log.debug('done failure method') status = 'failed' else: log.info('task succeeded: {}'.format(task)) status = 'done' done_task(task, id, status, next_tasks) log.debug('releasing sem') sem.release() proc = multiprocessing.Process(target=process_db_task) proc.start() def join_process(): proc.join() threading.Thread(target=join_process).start() return True
def carpool_list(): if request.args.get("id") is None: r = get_db().query( "SELECT * FROM carpools AS p JOIN concerts c ON c.id=p.concert JOIN carpool_members AS m ON m.carpool_id=p.id WHERE m.member_id=:id ORDER BY c.name", id=current_user.id) else: r = get_db().query("SELECT * FROM carpools WHERE concert=:concert", concert=request.args.get("id")) return json.dumps([x for x in r])
def carpool_get_msgs(): lookup = get_db()["carpool_members"].find_one( carpool_id=request.args.get("id"), member_id=current_user.id) if lookup is None: return abort(401, "Fail") r = get_db().query( "SELECT u.id, u.displayname, m.content FROM chat_messages AS m JOIN users AS u ON m.user_id=u.id WHERE carpool_id = :id ORDER BY time", id=request.args.get("id")) return json.dumps([x for x in r])
def GET(self): web.header("Content-Type", "text/html; charset=utf-8") node_id = web.input().get("node_id") nodes = get_db().query(models.RadNode).all() if node_id: users = get_db().query(models.RadUser)\ .filter(models.RadUser.node_id == node_id).all() else: users = get_db().query(models.RadUser).all() return render("user.html", nodes=nodes, node_id=node_id, users=users)
def GET(self): web.header("Content-Type","text/html; charset=utf-8") node_id = web.input().get("node_id") nodes = get_db().query(models.RadNode).all() if node_id: groups = get_db().query(models.RadGroup)\ .filter(models.RadGroup.node_id == node_id).all() else: groups = get_db().query(models.RadGroup).all() return render("group.html",nodes=nodes,node_id=node_id,groups=groups)
def GET(self): web.header("Content-Type","text/html; charset=utf-8") node_id = web.input().get("node_id") nodes = get_db().query(models.RadNode).all() if node_id: users = get_db().query(models.RadUser)\ .filter(models.RadUser.node_id == node_id).all() else: users = get_db().query(models.RadUser).all() return render("user.html",nodes=nodes,node_id=node_id,users=users)
def handle_pending_task(): db_task = utils.mongo_retry(lambda: get_db().tasks.find_one({'status': 'next_tasks_pending'})) if db_task is None: return False log.debug('handling pending task: {}'.format(db_task['class'])) insert_db_tasks(db_task['next_tasks']) utils.mongo_retry(lambda: get_db().tasks.update({'_id': db_task['_id']}, {'$set': {'status': db_task['next_status']}, '$unset': {'next_tasks': '', 'next_status': ''}})) log.debug('done handling pending task: {}'.format(db_task['class'])) return True
def GET(self): web.header("Content-Type", "text/html; charset=utf-8") node_id = web.input().get("node_id") nodes = get_db().query(models.RadNode).all() if node_id: groups = get_db().query(models.RadGroup)\ .filter(models.RadGroup.node_id == node_id).all() else: groups = get_db().query(models.RadGroup).all() return render("group.html", nodes=nodes, node_id=node_id, groups=groups)
def import_all(): """Imports all data files from DATA_PATH/export to database. File name is taken as collection name.""" db = utils.get_db() filenames = utils.get_json_filenames() status = True failed_writes = [] for fname in filenames: cname = fname.split('.')[0] try: collection = db[cname] filepath = CONFIG['DATA_PATH'] + '/import/' + fname command = 'mongoimport --db {0} --collection {1} --type json --file {2}'.format( CONFIG['DB_NAME'], cname, filepath) os.system(command) if True: logging.info("Wrote", cname, "to", cname + ".json") else: failed_writes.append(cname) except: logging.error("export_all(): Export failed!") traceback.print_exc() status = False if len(failed_writes) > 0: print("Failed to write", failed_writes) status = False return status
def do_put_blob(self, args): """put_blob [bucket] [size] [key] Create a blob with random content. size must be a number of bytes followed by an optional multiplier: K - 1024 M - 1048576 G - 1073741824 key is optional """ argv = args.split() if len(argv) == 2: bucket, size = argv key = None elif len(argv) == 3: bucket, size, key = argv else: self.do_help('put_blob') return if not re.match(r"\d+[KMG]?$", size): print "invalid size: {}".format(size) return if not size.endswith(("K", "M", "G")): num_bytes = size else: multiplier = {"K": 1024, "M": 1024 ** 2, "G": 1024 ** 3}[size[-1]] num_bytes = int(size[:-1]) * multiplier db = get_db(self.config) key = db.random_file(bucket, num_bytes, key) print "put {} ({} = {} bytes)".format(key, size, num_bytes)
def delete_all(): _db = utils.get_db() for table in _db.tables(): db = utils.select_table(table) db.remove(doc_ids=[doc.doc_id for doc in db.all()]) return jsonify({"message": "すべてのデータがリセットされました"})
def db_log_reading(self): if self.log_type and self.temp and self._execute_db_log(): db = get_db(self.coop) db.insert('coop_log', log_type='{}_TEMP'.format(self.log_type), log_value='{:.1f}'.format(float(self.temp))) self.last_db_log = arrow.utcnow()
def main(): global CACHE LOGGER.info('Starting alarm-clock') while True: now = datetime.datetime.now() today = now.strftime('%a').lower() db = get_db() playlist = db['playlist'] alarm_str = db['days'][today] if alarm_str is not None: hour, minute = alarm_str.split(':') alarm_hour = datetime.time(int(hour), int(minute)) dt = datetime.datetime.combine(now, alarm_hour) if not CACHE.get(dt, False): if dt <= now: res = play(playlist) if res: CACHE[dt] = True CACHE = trim_cache(CACHE) time.sleep(60)
def POST(self): web.header("Content-Type","text/html; charset=utf-8") form = forms.nas_add_form() if not form.validates(): return render("baseform.html",form=form,title="新增NAS设备",action="/nas/add") else: db = get_db() if db.query(models.RadNas).filter(models.RadNas.ip_addr == form.d.ip_addr).count()>0: return errorpage("Nas %s 已经存在"%form.d.ip_addr) try: nas = models.RadNas() nas.id = nextid() nas.ip_addr = form.d.ip_addr nas.name = form.d.name nas.auth_secret = form.d.auth_secret nas.acct_secret = form.d.acct_secret nas.vendor_id = form.d.vendor_id nas.time_type = form.d.time_type nas.status = form.d.status db.add(nas) db.commit() db.flush() except Exception,e: db.rollback() log.error("add nes error: %s"%str(e)) return errorpage("新增Nas失败 %s"%str(e)) raise web.seeother("/nas",absolute=True)
def show(): # Získá připojení na databázi # Pošle databázi "SELECT ..." SQL dotaz a výsledek uloží do proměnné cur cur = get_db().cursor() cur.execute( 'SELECT idAgendaItem, name FROM AgendaItem where item_type = \'C\' ORDER BY name' ) # Načte všechny řádky z výsledku toho SQL dotazu a uloží je do proměnné entries entries = cur.fetchall() cur.execute( 'SELECT idAgendaItem, name FROM AgendaItem WHERE item_type = \'TW\' ORDER BY name' ) workshops = cur.fetchall() # Pro každý řádek z výsledku udělej... for row in entries: # ... tenhle print(). V proměnné row je uložený seznam, který odpovídá # jednotlivým sloupečkům z SQL tabulky "mytable", na které jsme spustili # ten SQL dotaz - když se podíváš nahoru na ten SELECT dotaz, tak vidíš, # že jsme chtěli 3 sloupečky: id, name a date. Tady v chceme vypsat do # konzole jenom jméno a datum, takže vypíěeme row[1] a row[2] - v row[0] # je to id print(row[1]) # Zavolá funkci render_template(), která vezme template names.html, nahradí # v něm "names" za to, co je v proměnné "entries" a vygeneruje výsledné HTML, # které vrátí jako výsledek z téhle funkce zpátky do Fasku, a ten ji pošle # k uživateli do prohlížeče. try: return render_template('names.html', names=entries, workshops=workshops) except exceptions.TemplateSyntaxError as e: return "Template error: " + e.filename + " on line " + str(e.lineno)
def db_info(connection): """ Return a list of tables for this connection/database """ db = utils.get_db(connection) info = { 'tables': db.list_tables() } return jsonify(info)
def load_entry(): try: q = "" for i in str(request.args.get('q')): # q += chr(ord(i)-5) q += i device = str(int(q[:-10])) temp = str(int(q[-10:-7])) load = str(int(q[-7:])) # now = datetime.now() # midnight = now.replace(hour=0, minute=0, second=0, microsecond=0) # day = now.day # month = now.month # year = now.year # seconds = (now - midnight).seconds time = int(datetime.now().timestamp()) row = [time, temp, load] with open(get_db(device), 'a', newline='') as f: writer = csv.writer(f) writer.writerow(row) return jsonify(True) except Exception as e: return jsonify(exception_as_dict(e))
def _latest_game_day(): db = utils.get_db() last_day = dateparser.parse('2012-10-30') games = db.games.find().sort('date',-1) if games.count() == 0: return None return str(games[0].get('date'))
def POST(self): web.header("Content-Type","text/html; charset=utf-8") form = forms.group_add_form() if not form.validates(): return render("baseform.html",form=form,title="新增用户组",action="/group/add") else: db = get_db() if db.query(models.RadGroup)\ .filter(models.RadGroup.node_id == form.d.node_id)\ .filter(models.RadGroup.group_id == form.d.group_id)\ .count()>0: return errorpage("用户组编码重复") try: group = models.RadGroup() group.node_id = form.d.node_id group.group_id = form.d.group_id group.group_name = form.d.group_name db.add(group) db.commit() db.flush() except Exception,e: db.rollback() log.error("add group error: %s"%str(e)) return errorpage("新增用户组失败 %s"%str(e)) raise web.seeother("/group",absolute=True)
def done_task(task, id, status, next_tasks): if len(next_tasks) == 0: update = {'$set': {'status': status}} else: next_tasks_for_db = [task.for_db() for task in next_tasks] update = {'$set': {'status': 'next_tasks_pending', 'next_status': status, 'next_tasks': next_tasks_for_db}} utils.mongo_retry(lambda: get_db().tasks.update({'_id': id, 'status': 'running'}, update))
def POST(self): web.header("Content-Type","text/html; charset=utf-8") form = forms.product_add_form() if not form.validates(): return render("baseform.html",form=form,title="新增产品套餐",action="/product/add") else: db = get_db() if db.query(models.RadProduct).filter(models.RadProduct.id == form.d.id).count()>0: return errorpage("产品编号重复") try: radproduct = models.RadProduct() radproduct.id = form.d.id radproduct.name = form.d.name radproduct.policy = form.d.policy radproduct.fee_num = form.d.fee_num radproduct.fee_price = int(Decimal(form.d.fee_price)*100) radproduct.concur_number = form.d.concur_number radproduct.bind_mac = form.d.bind_mac radproduct.bind_vlan = form.d.bind_vlan radproduct.bandwidth_code = form.d.bandwidth_code radproduct.input_max_limit = form.d.input_max_limit radproduct.output_max_limit = form.d.output_max_limit radproduct.input_rate_code = form.d.input_rate_code radproduct.output_rate_code = form.d.output_rate_code radproduct.domain_code = form.d.domain_code radproduct.status = 0 db.add(radproduct) db.commit() db.flush() except Exception,e: db.rollback() log.error("add product error: %s"%str(e)) return errorpage("产品新增失败 %s"%str(e)) raise web.seeother("/product",absolute=True)
def get_game_ids_db(): """ looks up game_ids from db """ db = utils.get_db() game_docs = db.games.find({}, {'espn_game_id': True}) return [game['espn_game_id'] for game in game_docs]
def POST(self, none): web.header("Content-Type", "text/html; charset=utf-8") form = forms.product_update_form() if not form.validates(): return render("baseform.html", form=form, title="修改产品套餐", action="/product/update/") else: db = get_db() product = db.query(models.RadProduct).get(form.d.id) if not product: return errorpage("产品不存在") try: product.name = form.d.name product.fee_num = form.d.fee_num product.fee_price = int(Decimal(form.d.fee_price) * 100) product.concur_number = form.d.concur_number product.bind_mac = form.d.bind_mac product.bind_vlan = form.d.bind_vlan product.bandwidth_code = form.d.bandwidth_code product.input_max_limit = form.d.input_max_limit product.output_max_limit = form.d.output_max_limit product.input_rate_code = form.d.input_rate_code product.output_rate_code = form.d.output_rate_code product.domain_code = form.d.domain_code product.status = 0 db.commit() db.flush() except Exception, e: db.rollback() log.error("update product error: %s" % str(e)) return errorpage("修改套餐失败 %s" % str(e)) raise web.seeother("/product", absolute=True)
def find_shots(params={}): """ return all shots that match the passed in params """ db = utils.get_db() shots = db.shots.find(params) return shots
def insert_game_ids(): """ iterates through days and finds all espn game_ids from those days. inserts them into mongo db. """ #TODO: pass in progress callback db = utils.get_db() url = "http://scores.espn.go.com/nba/scoreboard" game_ids = set() last = _latest_game_day() for dt in utils.day_gen(last): day_str = dt.strftime(DT_FORMAT) try: resp = requests.get(url,params={'date':day_str}) cur_ids = re.findall('href="/nba/playbyplay\?gameId=(\d*)',resp.text) game_ids.update(cur_ids) for game_id in cur_ids: mongo_game_id = _gen_game_key(game_id) doc = {'date':dt,'espn_game_id':game_id,'_id':mongo_game_id} db.games.save(doc) except Exception as e: pdb.set_trace() return
def _insert_shots(game_id): db = utils.get_db() if db.shots.find({'espn_game_id':game_id}).count(): return shots = _get_shots(game_id) for shot in shots: db.shots.save(shot)
def create_database(current_courses): sql_create_projects_table = """ CREATE TABLE if not exists courses ( code text KEY, name text, groupe text KEY, lecturer text, type text, semester text, day text KEY, start INTEGER KEY, finish INTEGER, duration INTEGER, building INTEGER, room INTEGER ); """ # create a database connection conn = create_connection(utils.get_db()) if conn is not None: # create projects table cn = conn.cursor() cn.execute(sql_create_projects_table) fill_database(current_courses, cn) conn.commit() else: print("Error! cannot create the database connection.")
def get_game_ids_db(): """ looks up game_ids from db """ db = utils.get_db() game_docs = db.games.find({},{'espn_game_id':True}) return [game['espn_game_id'] for game in game_docs]
def left_right(): db = utils.get_db() left_f = shot_filters.merge_filters({'left':0}) left_df = DataFrame(list(db.shots.find(left_f))) n_l = len(left_df) left_p = len(left_df[left_df['made']]) / float(n_l) left_ci = utils.ci(left_p, n_l) right_f = shot_filters.merge_filters({'right':0}) right_df = DataFrame(list(db.shots.find(right_f))) n_r = len(right_df) right_p = len(right_df[right_df['made']]) / float(n_r) right_ci = utils.ci(right_p, n_r) # # hypothesis test: different sides of court # pooled_p = (left_p*n_l + right_p*n_r)/(n_r + n_l) # pooled_se = np.sqrt(pooled_p * (1-pooled_p) * ((1.0/n_l) + (1.0/n_r)) ) # pooled_z_stat = (right_p - left_p) / pooled_se json.dump([{ 'name': 'Right', 'value': right_p, 'l': right_ci[0], 'u': right_ci[1] }, { 'name': 'Left', 'value': left_p, 'l': left_ci[0], 'u': left_ci[1] }], open('static/data/left-right.json','w'))
def POST(self,none): web.header("Content-Type","text/html; charset=utf-8") form = forms.product_update_form() if not form.validates(): return render("baseform.html",form=form,title="修改产品套餐",action="/product/update/") else: db = get_db() product = db.query(models.RadProduct).get(form.d.id) if not product: return errorpage("产品不存在") try: product.name = form.d.name product.fee_num = form.d.fee_num product.fee_price = int(Decimal(form.d.fee_price)*100) product.concur_number = form.d.concur_number product.bind_mac = form.d.bind_mac product.bind_vlan = form.d.bind_vlan product.bandwidth_code = form.d.bandwidth_code product.input_max_limit = form.d.input_max_limit product.output_max_limit = form.d.output_max_limit product.input_rate_code = form.d.input_rate_code product.output_rate_code = form.d.output_rate_code product.domain_code = form.d.domain_code product.status = 0 db.commit() db.flush() except Exception,e: db.rollback() log.error("update product error: %s"%str(e)) return errorpage("修改套餐失败 %s"%str(e)) raise web.seeother("/product",absolute=True)
def POST(self): web.header("Content-Type", "text/html; charset=utf-8") form = forms.group_add_form() if not form.validates(): return render("baseform.html", form=form, title="新增用户组", action="/group/add") else: db = get_db() if db.query(models.RadGroup)\ .filter(models.RadGroup.node_id == form.d.node_id)\ .filter(models.RadGroup.group_id == form.d.group_id)\ .count()>0: return errorpage("用户组编码重复") try: group = models.RadGroup() group.node_id = form.d.node_id group.group_id = form.d.group_id group.group_name = form.d.group_name db.add(group) db.commit() db.flush() except Exception, e: db.rollback() log.error("add group error: %s" % str(e)) return errorpage("新增用户组失败 %s" % str(e)) raise web.seeother("/group", absolute=True)
def _latest_game_day(): db = utils.get_db() last_day = dateparser.parse('2012-10-30') games = db.games.find().sort('date', -1) if games.count() == 0: return None return str(games[0].get('date'))
def answer(): if 'username' not in session: return redirect(url_for("login", next="answer")) if session['role'] != 'expert' and session['role'] != 'admin': abort(403) cursor = get_db_cursor() if request.method == 'POST': db = get_db() cursor.execute( "INSERT INTO answers (body, question_id, answer_owner) VALUES (%s, %s, %s)", (request.form.get("answer"), request.args.get("id"), session["username"])) cursor.execute("UPDATE questions SET status='answered' WHERE id=%s", (request.args.get("id"), )) db.commit() flash("Your answer was submitted successfully!", "success") return redirect(url_for('answer')) cursor.execute( "SELECT * FROM questions WHERE status='not answered' and asked_username=%s", (session["username"], )) questions = cursor.fetchall() return render_template("answer.html", title="Answer Questions", questions=questions)
def insert_game_ids(): """ iterates through days and finds all espn game_ids from those days. inserts them into mongo db. """ #TODO: pass in progress callback db = utils.get_db() url = "http://scores.espn.go.com/nba/scoreboard" game_ids = set() last = _latest_game_day() for dt in utils.day_gen(last): day_str = dt.strftime(DT_FORMAT) try: resp = requests.get(url, params={'date': day_str}) cur_ids = re.findall('href="/nba/playbyplay\?gameId=(\d*)', resp.text) game_ids.update(cur_ids) for game_id in cur_ids: mongo_game_id = _gen_game_key(game_id) doc = { 'date': dt, 'espn_game_id': game_id, '_id': mongo_game_id } db.games.save(doc) except Exception as e: pdb.set_trace() return
def _insert_shots(game_id): db = utils.get_db() if db.shots.find({'espn_game_id': game_id}).count(): return shots = _get_shots(game_id) for shot in shots: db.shots.save(shot)
def post(self): """ there is one way to access this endpoint via a post request with the data in the body of the request 1) /api/v1/users -> creates a new user and returns their id """ conn = get_db() conn.row_factory = dict_factory c = conn.cursor() parser = reqparse.RequestParser() parser.add_argument("email", type=str, required=True) parser.add_argument("password", type=str, required=True) args = parser.parse_args() email = args["email"] password = args["password"] c.execute("INSERT INTO users (email, password) VALUES (?,?)", (email, password)) conn.commit() last_row_id = c.lastrowid return {"id": last_row_id}
def delete(self): """ there is one way to access this endpoint via a delete request 1) /api/v1/users -> this will delete all users 2) /api/v1/users/{id} -> this will delete the user associated with the id """ conn = get_db() conn.row_factory = dict_factory c = conn.cursor() parser = reqparse.RequestParser() parser.add_argument("id", type=str, required=False) args = parser.parse_args() user_id = args["id"] if user_id != None: c.execute("DELETE FROM users WHERE id ='" + user_id + "'") conn.commit() return c.execute("DELETE FROM users") conn.commit()
def quarterly(): db = utils.get_db() shots = list(db.shots.find()) shots_df = DataFrame(shots) q1 = shots_df['qtr'] == '1' q2 = shots_df['qtr'] == '2' q3 = shots_df['qtr'] == '3' q4 = shots_df['qtr'] == '4' q1q2 = np.any([shots_df['qtr'] == '1', shots_df['qtr'] == '2'], 0) qtr_ps = { 'Q1': [len(shots_df[np.all([q1, shots_df['made']], 0)]) / float(len(shots_df[q1])), len(shots_df[q1])], 'Q2': [len(shots_df[np.all([q2, shots_df['made']], 0)]) / float(len(shots_df[q2])), len(shots_df[q2])], 'Q3': [len(shots_df[np.all([q3, shots_df['made']], 0)]) / float(len(shots_df[q3])), len(shots_df[q3])], 'Q4': [len(shots_df[np.all([q4, shots_df['made']], 0)]) / float(len(shots_df[q4])), len(shots_df[q4])], # 'q1q2': [len(shots_df[np.all([q1q2, shots_df['made']], 0)]) / float(len(shots_df[q1q2])), len(shots_df[q1q2])] } cis = {} for q in qtr_ps: cis[q] = utils.ci(qtr_ps[q][0], qtr_ps[q][1]) json.dump([{ 'name': q, 'value': qtr_ps[q][0], 'l': cis[q][0], 'u': cis[q][1] } for q in qtr_ps], open('static/data/quarterly.json','w'))
def delete(self): """ there two ways to access this endpoint via a delete request 1) /api/v1/notes -> this will delete all notes (yikes) 2) /api/v1/notes/{id} -> this will delete the notes associated with the id """ conn = get_db() conn.row_factory = dict_factory c = conn.cursor() parser = reqparse.RequestParser() parser.add_argument("id", type=str, required=False, location="args") args = parser.parse_args() # if we have indeed found and id let's get the corresponding notes assuming they exist notes_id = args["id"] if notes_id != None: c.execute("SELECT * FROM notes WHERE id='" + notes_id + "'") requested_notes = c.fetchone() if requested_notes == None: print "Those notes don't exist :O" abort(400) os.remove(requested_notes["filename"]) c.execute("DELETE FROM notes WHERE id ='" + notes_id + "'") conn.commit() return c.execute("DELETE FROM notes") conn.commit()
def save_to_mongo(self, data): """ 增加方法:将数据存入mongodb数据库中 """ if isinstance(data, dict): mongo_db = get_db() mongo_db[RESULT_COLLECTIONS_NAME].insert(data)
def carpool_suggest(): if request.args.get("id") is None: result = [] with get_neo_db().session() as session: for r in session.run( "MATCH (u:User {id:$user_id}), (b:User) " "WHERE u <> b AND distance(b.location, u.location) < $radius " "WITH u, b " "MATCH (b)-[:IN]->(c) " "WHERE NOT (u)-[:IN]->(c) " "WITH DISTINCT u, c " "MATCH (b)-[:IN]->(c), (b)-[:LIKES]->(s)<-[:LIKES]-(u) " "WITH u, c, b, count(s) AS similarity_i " "WITH u, c, avg(similarity_i) AS similarity " "MATCH (b)-[:IN]->(c)-[:FOR]->(concert) " "RETURN c, similarity, min(distance(u.location, b.location)) AS dist, concert " "ORDER BY similarity DESC", radius=float(request.args.get("radius")), user_id=current_user.id): r2 = get_db().query("SELECT name FROM concerts WHERE id=:id", id=r["concert"].get("id")) result.append({ "id": r["c"].get("id"), "similarity": r["similarity"], "name": r2.next()["name"], "dist": r["dist"] }) return json.dumps(result) else: result = [] with get_neo_db().session() as session: for r in session.run( "MATCH (u:User {id:$user_id}), (b)-[:IN]->(p)-[:FOR]->(c:Concert {id:$for_id}) " "WITH p, min(distance(u.location, b.location)) AS dist " "RETURN p, dist " "ORDER BY dist", for_id=int(request.args.get("id")), user_id=current_user.id): r2 = get_db().query( "SELECT car_description FROM carpools WHERE id=:id", id=r["p"].get("id")) result.append({ "id": r["p"].get("id"), "dist": r["dist"], "desc": r2.next()["car_description"] }) return json.dumps(result)
def GET(self,productid): web.header("Content-Type","text/html; charset=utf-8") form = forms.product_update_form() db = get_db() product = db.query(models.RadProduct).get(productid) form.fill(product) form.fee_price.set_value(product.fee_price/100.00) return render("baseform.html",form=form,title="修改产品套餐",action="/product/update/")
def total_quarterly(): db = utils.get_db() num_shots = [] for i in range(1,5): params = {'quarter': '%i' % i} shots = db.shots.find(shot_filters.merge_filters(params)) num_shots.append({'name': 'Q%i' % i, 'value': shots.count()}) json.dump(num_shots, open('static/data/total_quarterly.json','w'))
def _select_espn_game_ids(): """ returns a set of all espn game ids already in the db """ db = utils.get_db() docs = db.games.find({}, {'espn_game_id': True}) game_ids = set([doc['espn_game_id'] for doc in docs]) return game_ids
def _select_espn_game_ids(): """ returns a set of all espn game ids already in the db """ db = utils.get_db() docs = db.games.find({},{'espn_game_id':True}) game_ids = set([doc['espn_game_id'] for doc in docs]) return game_ids
def add_entry(): if not flask.session.get('logged_in'): abort(401) db = utils.get_db() db.execute('insert into entries (title, text) values (?, ?)', [flask.request.form['title'], flask.request.form['text']]) db.commit() flask.flash('New entry was successfully posted') return flask.redirect(url_for('show_entries'))
def do_list_buckets(self, args): db = get_db(self.config) try: buckets = db.get_buckets() except Exception as e: print e else: for bucket in buckets: print bucket
def test(): q_params = {'min_distance':'20', 'quarter':'1', 'last_name':'smith', 'home':True} mongo_filter = merge_filters(q_params) db = utils.get_db() print db.shots.find(mongo_filter).count()
def main(): #init symbols = utils.get_symbols(SYMBOL_FILE) db = utils.get_db(SQLITE_FILE) #download data from website, then update the database. #init_data(db, symbols) analysis_data(db, symbols)
def do_clear(self, args): """clear [bucket [bucket ...]]""" db = get_db(self.config) if args: buckets = args.split() else: buckets = db.get_buckets() for bucket in buckets: deleted = db.clear(bucket) print "removed {} objects from {!r} bucket".format(deleted, bucket)
def do_list_bucket_keys(self, bucket_name): """list_bucket_keys [bucket]""" db = get_db(self.config) try: keys = db.get_bucket_keys(bucket_name) except Exception as e: print e else: for key in keys: print key
def GET(self): web.header("Content-Type","text/html; charset=utf-8") user_id = web.input().get("user_id") db = get_db() user = db.query(models.RadUser).get(user_id) form = forms.user_update_form() form.fill(user) form.group_id.args = getGroupIds(user.node_id) form.group_id.value = user.group_id form.password.value = decrypt(user.password) return render("baseform.html",form=form,title="修改用户",action="/user/update")
def GET(self): web.header("Content-Type","text/html; charset=utf-8") node_id = web.input().get("node_id") group_id = web.input().get("group_id") db = get_db() group = db.query(models.RadGroup)\ .filter(models.RadGroup.node_id == node_id)\ .filter(models.RadGroup.group_id == group_id).first() form = forms.group_update_form() form.fill(group) return render("baseform.html",form=form,title="修改用户组",action="/group/update")
def do_put(self, args): """put [bucket] [key] [contents]""" try: bucket, key, content = args.split(' ') except: self.do_help('put') return db = get_db(self.config) db.get_bucket(bucket) print db.create_file(bucket, key, content)
def GET(self,nasid): if nasid: db = get_db() try: for nas in db.query(models.RadNas).filter(models.RadNas.id == nasid): db.delete(nas) db.commit() db.flush() except Exception,e: db.rollback() log.error("delete nas error: %s"%str(e)) return errorpage("删除失败 %s"%str(e))