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 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 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))
