def postData():
if request.method == 'POST':
username = request.form.get('username')
distance = request.form.get('distance')
duration = request.form.get('duration')
averagespeed = request.form.get('averagespeed')
pathline = request.form.get('pathline')
startpoint = request.form.get('startpoint')
endpoint = request.form.get('endpoint')
date = request.form.get('date')
if session.get(username):
newRecord = Record(username, distance, duration, averagespeed,
pathline, startpoint, endpoint, date)
try:
db.session.add(newRecord)
db.session.commit()
db.session.close()
print('用户 {} 添加一条记录'.format(username))
return jsonify({'msg': '同步记录成功！', 'state': 'success'})
except:
db.session.rollback()
return jsonify({'msg': 'sql 执行错误！', 'state': 'fail'})
else:
return jsonify({'msg': '用户未登录！', 'state': 'fail'})
def get(self):
data = genfromtxt("./input.txt",
delimiter=',',
skip_header=1,
dtype=str)
data = data.tolist()
for row in data:
description = row[1]
datetime = row[2]
longitude = row[3]
latitude = row[4]
elevation = row[5]
record = Record(description=description,
datetime=datetime,
longitude=longitude,
latitude=latitude,
elevation=elevation)
db.session.add(record)
# db.session.flush()
db.session.commit()
return {"message": "CSV file uploaded to database!"}
def get_records_by_execution_id(execution_id, conn):
"""This function returns a records list of Execution for a specific execution id"""
records = []
# generated_records = []
cursor = conn.cursor()
sql_records_by_execution_id = "select id, business_key, execution_id, record_hash, record_type from Record where " \
"execution_id = '%s' and record_type in ('source', 'generated') "
# SQL Records
query_result = cursor.execute(sql_records_by_execution_id %
execution_id).fetchall()
for row in query_result:
record = Record(str(row["business_key"]),
get_columns_by_record_id(row["id"], conn))
# The business key could be a simple int but we handle it as string since python is not
# statically typed.
record.record_hash = row["record_hash"]
record.record_type = row["record_type"]
records.append(record)
# Generated Records (record_type = 'framework')
# No Use-Case
# but could be used to re-produce a generated report file at any time
if not records:
print "Error : no record found for execution " + execution_id
return records
def add_record(self):
"""add new record to the database"""
item_list = view.enter_trip_details(input, input, input)
if mdl.check_validity(item_list):
self.model.records.append(
Record(item_list[0], item_list[1], item_list[2]))
else:
view.invalid_value()
def save_image(self, image, user_id, detected_keyword):
for k in detected_keyword:
image_name = f'{time.time()}.jpg'
cv2.imwrite(f'/media/storage/images/{image_name}', image, [cv2.IMWRITE_JPEG_QUALITY, 20])
record = Record(channel=self.args.channelname, time=datetime.datetime.now(), keyword=k,
image=image_name, user_id=user_id)
self.session.add(record)
self.session.flush()
self.session.commit()
def load_record():
test1 = Record(profile_id=1,
food_id=1,
date=datetime.date.today(),
serving_qty=1,
serving_unit='container',
serving_weight_grams=111)
test2 = Record(profile_id=1,
food_id=2,
date=datetime.date.today(),
serving_qty=3,
serving_unit='cup',
serving_weight_grams=246)
db.session.add(test1)
db.session.add(test2)
db.session.commit()
def add_record(self, classes, day):
# 添加上课记录,同时添加学生的逻辑关联对象Homework
record = Record(Day=day)
classes.record.append(record)
for student in classes.student:
homework = Homework(student_id=student.id,
submit=False,
score=None)
record.homework.append(homework)
self.Session.commit()
def merge_author(d = {}):
merged_d = {}
for a in d.items():
r = a[1]
k = "{0}_{1}".format(r.name.replace(" ", '-').lower(), r.organization.replace(' ', "_").lower())
if k not in merged_d:
merged_d[k] = Record(k)
merged_d[k].name = r.name
merged_d[k].organization = r.organization
merged_d[k].first.extend(r.first)
merged_d[k].other.extend(r.other)
return merged_d
def poll_sensor(mac, location_id):
attempts = 0
while attempts < 5:
try:
poller = MiTempBtPoller(mac, BluepyBackend)
t = poller.parameter_value(MI_TEMPERATURE, read_cached=False)
h = poller.parameter_value(MI_HUMIDITY, read_cached=False)
now = datetime.datetime.now()
Record(temperature=t, humidity=h, date=now,
location=location_id).save()
break
except BluetoothBackendException:
time.sleep(10)
attempts += 1
def load_records():
"""Load fake records with fake information into database"""
with open('seed_data/records.csv', 'rb') as csvfile:
data = csv.reader(csvfile)
for row in data:
record_id, user_id, common_name, date_time, latitude, longitude, notes, seen, num_birds = row
record = Record(record_id=record_id, user_id=user_id, common_name=common_name,
date_time=date_time, latitude=latitude, longitude=longitude,
notes=notes, seen=seen, num_birds=num_birds)
db.session.add(record)
db.session.commit()
def parse_query_result(query_result, this_execution, columns, columns_mapping):
"""Reads and parses data source query result and add it to
existing execution instance"""
columns_in_business_key = []
for column_name, column_definition in columns_mapping.items():
if "is_business_key" in column_definition:
if column_definition["is_business_key"] == '1':
columns_in_business_key.append(str(column_name))
for row in query_result:
# Construct the business key (record.id)
# this_record = Record(row[0])
# New method
business_key = []
for a_column in columns_in_business_key:
business_key.append((a_column, row[a_column]))
business_key.sort(key=lambda column_tuple: column_tuple[0])
record_id = [column_tuple[1] for column_tuple in business_key]
if len(record_id) == 1:
record_id = str(record_id[0])
else:
record_id = ''.join(record_id)
this_record = Record(record_id=record_id)
# End of new method for business key
this_record.record_type = 'source' # This record was read from a report query
# This approach is independent of the column order in the SQL defined
# in the report configuration
for a_column in columns:
a_column = str(a_column)
this_column = Column(
a_column, str(row[a_column]),
columns_mapping[a_column]["is_used_for_compare"])
this_record.columns.append(this_column)
this_record.hash_record()
this_execution.add_record(this_record)
def addRecord(**args):
session = connectdb()
cat = session.query(Catagory).filter_by(name=args['cat'])
if cat.all():
catobj = cat.one()
else:
catobj = Catagory(args['cat'])
taskobj = Task(args['task'])
taskobj.cat = catobj
# if True:
# session.add(task)
# date = args['date'].today()
record = Record(args['date'], args['start_time'], args['big_or_not'])
record.task = taskobj
session.merge(
record
) # cat and task will save/update automatically and cascade due to the session's default setting?
my_db_commit(session)
session.close()
def post(self):
json_data = request.get_json(force=True)
if not json_data:
return {'message': 'No input data provided'}, 400
# Validate and deserialize input
data, errors = record_schema.load(json_data)
if errors:
return errors, 422
record = Record(description=data['description'],
longitude=data['longitude'],
latitude=data['latitude'],
elevation=data['elevation'])
db.session.add(record)
db.session.commit()
result = record_schema.dump(record).data
return {"status": 'success', 'data': result}, 201
def addRecord():
if 'username' in session:
print('I will add record in ' + session['username'])
theDatetime = request.form['theDatetime']
content = request.form['content']
#生成待插入记录的对象并进行插入
record = Record(username=session['username'],
content=content,
state=0,
timing=theDatetime)
db.session.add(record)
db.session.commit()
#获取datetime进行格式化
print(theDatetime)
d = datetime.strptime(theDatetime, "%Y-%m-%dT%H:%M")
print(d)
scheduler.add_job(doJob,
'date',
run_date=d,
args=[session['username'], content])
return redirect(url_for('show'))
def get_speakers(poster, speaker_dict = {}):
print("get speakers by poster: " + poster.id)
try:
r = session.get(poster_detail_url.format(poster.id))
soup = BeautifulSoup(r.text, features="html.parser")
tags = soup.find_all('button', {"onclick": re.compile(r"showSpeaker.*")})
for i, a in enumerate(tags):
ids = re.compile(r"[\d | -]+").findall(a["onclick"])
if len(ids)>0 :
id = ids[0]
if (id not in speaker_dict):
speaker_dict[id] = Record(ids[0])
record = speaker_dict[id]
if i == 0 and (poster.title not in record.first):
record.add_first(poster.title)
if i > 0 and (poster.title not in record.other):
record.add_other(poster.title)
get_speakers_detail(record)
except requests.exceptions.RequestException as e: # This is the correct syntax
print(e)
return speaker_dict
def handle_maths_game(json):
if json['status'] == 'finish':
finalScore = json['final_score']
pre_record = Record.query.filter_by(
score_type="math", record_date=datetime.now().date()).first()
if pre_record is None:
db.session.add(
Record(email=session['ind_email'],
score_type="math",
score=finalScore))
db.session.commit()
else:
pre_record.score = max(pre_record.score, finalScore)
db.session.commit()
emit('maths',
json,
broadcast=True,
namespace='/individual/' + session['ind_uuid'])
print('Maths received json: ' + str(json))
def new_record():
"""Form for user to add new record. Store in database"""
user_id = request.form.get("user_id")
common_name = request.form.get("common_name")
date_time = request.form.get("date_time")
latitude = request.form.get("lat")
longitude = request.form.get("lng")
notes = request.form.get("notes")
seen = request.form.get("seen")
num_birds = request.form.get("num_birds")
new_record = Record(user_id=user_id,
common_name=common_name,
date_time=date_time,
latitude=latitude,
longitude=longitude,
notes=notes,
seen=seen,
num_birds=num_birds)
db.session.add(new_record)
db.session.commit()
# jsonify dictionary and return that
# This is just for display purposes, so it doesn't need everything
new_rec_dic = {
"common name": common_name,
"date_time": date_time,
"latitude": latitude,
"longitude": longitude,
"notes": notes,
"seen": seen,
"num birds": num_birds
}
return jsonify(new_rec_dic)
def game_music():
global qna, model, index2word_set
if request.method == 'GET':
musicFilesPath = ROOT_DIR + '/static/music/'
musicfiles = [
f for f in listdir(musicFilesPath)
if isfile(join(musicFilesPath, f))
]
musicfiles = [x for x in musicfiles if x != ".DS_Store"]
random.shuffle(musicfiles)
finalMusicFilesNames = musicfiles[0:5]
finalMusicFilesPath = [('music/' + x) for x in finalMusicFilesNames]
onlyNames = []
for musicName in finalMusicFilesNames:
a, b = musicName.split("-")
onlyNames.append(a)
return render_template('music-index.html',
finalMusicFilesPath=finalMusicFilesPath,
onlyNames=onlyNames)
if request.method == 'POST':
score = 0
n_score = 0
for key, value in request.form.to_dict().items():
a, b, c = key.split("-")
if c == value:
score += 1
else:
n_score += 1
finalScore = (score / (score + n_score)) * 100
pre_record = Record.query.filter_by(
score_type="musical", record_date=datetime.now().date()).first()
if pre_record is None:
db.session.add(
Record(email=session['ind_email'],
score_type="musical",
score=finalScore))
db.session.commit()
else:
pre_record.score = max(pre_record.score, finalScore)
db.session.commit()
emit('music', {
'final_score': finalScore,
"status": "finish"
},
broadcast=True,
namespace='/individual/' + session['ind_uuid'])
return "Your Feedback is submitted! This Window will automatically close shortly!!"
def addRecords(
filename='/home/leon/Documents/Golden_Agents/begraafregisters-voor-1811/data/SAA_Index_op_begraafregisters_voor_1811_20190207.xml.gz'
):
cachedict = None
# load file
if filename.endswith('.gz'):
with gzip.open(filename) as gzipfile:
tree = etree.parse(gzipfile)
elif filename.endswith('.xml'):
tree = etree.parse(filename)
existing_ids = set(i[0] for i in session.query(Record.id).all())
### Add records
records = tree.findall("//indexRecord")
n_total = len(records)
for n, record in enumerate(records, 1):
if record.attrib['id'] in existing_ids:
continue
print(record.attrib['id'])
if n % 1000 == 0:
print(f"{n}/{n_total} records", end='\r')
session.commit()
# break
if record.find('datumBegrafenis') is not None:
try:
date = datetime.fromisoformat(
record.find('datumBegrafenis').text)
except:
date = None
else:
date = None
r = Record(id=record.attrib['id'],
inventory=record.find('inventarisnummer').text,
date=date)
if record.find('begraafplaats') is not None:
church, cachedict = get_one_or_create(
session,
Church,
cachedict=cachedict,
name=record.find('begraafplaats').text)
else:
church = None
if record.find('bronverwijzing') is not None:
source = record.find('bronverwijzing').text
else:
source = None
if record.find('urlScan') is not None:
scan, cachedict = get_one_or_create(
session,
Scan,
cachedict=cachedict,
url=record.find('urlScan').text)
else:
scan = None
if record.find('relatieinformatie') is not None:
relationinfo, cachedict = get_one_or_create(
session,
Relationinfo,
cachedict=cachedict,
name=record.find('relatieinformatie').text)
else:
relationinfo = None
r.scan = scan
r.church = church
r.source = source
r.relationinfo = relationinfo
for ingeschrevene in record.findall('ingeschrevene'):
givenNames = ingeschrevene.find('voornaam')
if givenNames is not None:
givenName = givenNames.text
else:
givenName = None
surnamePrefixes = ingeschrevene.find('tussenvoegsel')
if surnamePrefixes is not None:
surnamePrefix = surnamePrefixes.text
else:
surnamePrefix = None
baseSurnames = ingeschrevene.find('achternaam')
if baseSurnames is not None:
baseSurname = baseSurnames.text
else:
baseSurname = None
literalName = " ".join([
i for i in [givenName, surnamePrefix, baseSurname]
if i is not None
])
pn, cachedict = get_one_or_create(session,
Personname,
cachedict=cachedict,
givenname=givenName,
surnameprefix=surnamePrefix,
basesurname=baseSurname,
literalname=literalName)
# p = Person(name=literalName)
p = Person()
p.names.append(pn)
r2p = Record2person(buried=False)
r2p.person = p
r.registered.append(r2p)
session.add(r)
session.commit()
def create(self, request, relpath, name=None, value=None):
client = ndb.Client()
with client.context():
r = Record(name=name, value=value)
r.put()
return "OK"
def add_chat_record(self, content):
question_answer = Record(content, self.user)
question_answer.save()
def addfood():
foodname = request.form.get("inputfood", "applesauce")
profileid = request.form.get("profileid", 1)
inputdate = request.form.get("inputdate", "2018-10-07")
food_object = Food.query.filter(Food.food_name == foodname).first()
if not food_object:
print("{} does not exist in SQL. Creating Food".format(foodname))
headers = {
"x-app-id": secrets.NUTRITIONIX_ID,
"x-app-key": secrets.NUTRITIONIX_KEY,
"Content-Type": "application/json"
}
data = {"query": foodname}
r = requests.post(
'https://trackapi.nutritionix.com/v2/natural/nutrients',
headers=headers,
json=data)
json_data = json.loads(r.text).get("foods")[0]
nutrient_data = {}
for item in json_data.get("full_nutrients"):
nutrient_data["attr_{}".format(item['attr_id'])] = item['value']
altr_measures = {}
if json_data.get("alt_measures"):
for item in json_data.get("alt_measures"):
altr_measures[item["measure"]] = item["serving_weight"]
str_alt_measures = ", ".join([
"{}:{}".format(key, value)
for (key, value) in altr_measures.items()
])
else:
str_alt_measures = ""
test1 = Food(
food_name=json_data.get("food_name"),
brand_name=None,
serving_qty=json_data.get("serving_qty"),
serving_unit=json_data.get("serving_unit"),
serving_weight_grams=json_data.get("serving_weight_grams"),
calories=json_data.get("nf_calories", 0),
carbohydrates=json_data.get("nf_total_carbohydrate", 0),
fiber=json_data.get("nf_dietary_fiber", 0),
fat=json_data.get("nf_total_fat", 0),
protein=json_data.get("nf_protein", 0),
vitA=nutrient_data.get("attr_320", 0),
vitC=nutrient_data.get("attr_401", 0),
vitD=nutrient_data.get("attr_328", 0),
vitE=nutrient_data.get("attr_323", 0),
vitB6=nutrient_data.get("attr_415", 0),
vitB12=nutrient_data.get("attr_418", 0),
thiamin=nutrient_data.get("attr_404", 0),
riboflavin=nutrient_data.get("attr_405", 0),
niacin=nutrient_data.get("attr_406", 0),
folate=nutrient_data.get("attr_417", 0),
calcium=nutrient_data.get("attr_301", 0),
copper=nutrient_data.get("attr_312", 0),
iodine=0,
iron=nutrient_data.get("attr_303", 0),
magnesium=nutrient_data.get("attr_304", 0),
phosphorus=nutrient_data.get("attr_305", 0),
selenium=nutrient_data.get("attr_317", 0),
zinc=nutrient_data.get("attr_309", 0),
potassium=json_data.get("nf_potassium") / 1000,
sodium=nutrient_data.get("attr_307", 0) / 1000,
chloride=0,
alt_measures=str_alt_measures)
db.session.add(test1)
db.session.commit()
print(test1.food_id)
else:
print(food_object)
print("FOOD IS FOUND. DONT MESS UP")
newfood = Food.query.filter(Food.food_name == foodname).first()
print(newfood)
newrecord = Record(profile_id=profileid,
food_id=newfood.food_id,
date=inputdate,
serving_qty=0,
serving_unit=newfood.serving_unit,
serving_weight_grams=newfood.serving_weight_grams)
db.session.add(newrecord)
db.session.commit()
print(newrecord.record_id)
return render_template("record_ajax.html", item=newrecord)
import pendulum
from repository import JSONRepository
from model import Record, Status
repo = JSONRepository('./database.json')
record = Record('0', 'K-19: The Widowmaker', Status.TO_WATCH.name,
{'imdb': 'https://www.imdb.com/title/tt0267626/'})
print(record.__dict__)
repo.save(record)
record = Record('1', 'Finding Dory', Status.TO_WATCH.name,
{'imdb': 'https://www.imdb.com/title/tt2277860/'})
print(record.__dict__)
repo.save(record)
record = Record('2',
'Memento',
Status.WATCHED.name,
{'imdb': 'https://www.imdb.com/title/tt0209144/'},
date_watched=pendulum.datetime(2018, 4,
26).to_iso8601_string())
print(record.__dict__)
repo.save(record)
print(repo.retrieve('na'))
def add_aq_to_db():
dates_and_values = aq_data.get_aq_data()
for item in dates_and_values:
db_record = Record(datetime=str(item[0]), value=item[1])
DB.session.add(db_record)
from model import db, Record
import random
from datetime import datetime, timedelta
N = 30
features = [
"visual", "verbal", "math", "intrapersonal", "logical", "body", "musical",
"nature"
]
while (N >= 0):
start_date = datetime.now() - timedelta(N)
email = "*****@*****.**"
for i in range(4):
finalScore = random.randint(10, 70)
choice = random.choice(features)
print(choice)
pre_record = Record.query.filter_by(
score_type=choice, record_date=start_date.date()).first()
if pre_record is None:
db.session.add(
Record(email=email,
score_type=choice,
score=finalScore,
record_date=start_date.date()))
db.session.commit()
else:
pre_record.score = max(pre_record.score, finalScore)
db.session.commit()
N -= 1
def initEmptyRecord(self):
return Record(uuid=uuid4(),
date_created=datetime.utcnow(),
date_modified=datetime.utcnow(),
frbr_status='to_do',
cluster_status=False)
def testRecord(self):
return Record(uuid='Test UUID',
title='Test Title',
languages=['English|en|eng'],
has_version='first edition')
def game_video():
global qna, model, index2word_set
if request.method == 'GET':
video_name = 'v1'
video_path = 'videos/' + video_name + '.mp4'
listOfQuestions = []
questions = qna[video_name]
for key, value in questions.items():
listOfQuestions.append(value["question"])
return render_template('video-index.html',
listOfQuestions=listOfQuestions,
video_name=video_name,
video_path=video_path)
if request.method == 'POST':
score = 0
n_score = 0
for key, value in request.form.to_dict().items():
a, b = key.split("-")
exp_answers = qna[a][b]["answers"]
maxScore = 0.0
value = value.lower()
for ea in exp_answers:
ea = ea.lower()
maxScore = max(
maxScore,
SimilarityModel.predict(model, index2word_set, ea, value))
print(maxScore)
if maxScore > 50.0:
score += 1
else:
n_score += 1
finalScore = (score / (score + n_score)) * 100
pre_record = Record.query.filter_by(
score_type="visual", record_date=datetime.now().date()).first()
if pre_record is None:
db.session.add(
Record(email=session['ind_email'],
score_type="visual",
score=finalScore))
db.session.commit()
else:
pre_record.score = max(pre_record.score, finalScore)
db.session.commit()
emit('video', {
'final_score': finalScore,
"status": "finish"
},
broadcast=True,
namespace='/individual/' + session['ind_uuid'])
return "Your Feedback is submitted! This Window will automatically close shortly!!"
def store_record(patient, date_text, injury_text, treatment_text, followup_text):
record = Record(date_text, injury_text, treatment_text, treatment_text, followup_text )
print record.record_details
controller.store_record(patient['stu_id'],record.record_details)
call_patient_frame_on_top(patient)
def game_nature():
global qna, model, index2word_set, nature
if request.method == 'GET':
natureFilesPath = ROOT_DIR + '/static/nature/'
naturefiles = [
f for f in listdir(natureFilesPath)
if isfile(join(natureFilesPath, f))
]
naturefiles = [x for x in naturefiles if x != ".DS_Store"]
random.shuffle(naturefiles)
finalNatureFilesNames = naturefiles[0:5]
finalNatureFilesPath = [('nature/' + x) for x in finalNatureFilesNames]
onlyNames = []
for musicName in finalNatureFilesNames:
a, b = musicName.split(".")
onlyNames.append(a)
return render_template('nature-index.html',
finalNatureFilesPath=finalNatureFilesPath,
onlyNames=onlyNames)
if request.method == 'POST':
score = 0
n_score = 0
for key, value in request.form.to_dict().items():
a, b = key.split("~")
maxScore = 0
value = value.lower()
for ea in nature[a]['answers']:
ea = ea.lower()
maxScore = max(
maxScore,
SimilarityModel.predict(model, index2word_set, ea, value))
if maxScore > 50.0:
score += 1
else:
n_score += 1
finalScore = (score / (score + n_score)) * 100
pre_record = Record.query.filter_by(
score_type="nature", record_date=datetime.now().date()).first()
if pre_record is None:
db.session.add(
Record(email=session['ind_email'],
score_type="nature",
score=finalScore))
db.session.commit()
else:
pre_record.score = max(pre_record.score, finalScore)
db.session.commit()
emit('nature', {
'final_score': finalScore,
"status": "finish"
},
broadcast=True,
namespace='/individual/' + session['ind_uuid'])
return "Your Feedback is submitted! This Window will automatically close shortly!!"
