def make_log_string(r_data, code):
"""
Логируем запрос, создаем запись в базу
"""
r_uid = current_user_id()
r_addr = flask.request.environ['REMOTE_ADDR']
r_uri = flask.request.environ['REQUEST_URI']
r_time = str(datetime.now())
record_string = f"""
===========================
Request info:
time: {r_time}
remote address: {r_addr}
uri: {r_uri}
user id: {r_uid}
data: {r_data}
host response: {code}
===========================
"""
Record.create_record(
app=current_app,
db=db,
record_uri=r_uri,
user_id=r_uid,
)
return record_string
def ImportAllRecords(csvFile):
num = 0
with open(csvFile) as csvTextFile:
csvReader = csv.reader(csvTextFile)
for line in csvReader:
print(line[0])
if num > 0:
record = Record(EnterpriseId=int(line[0]),
LastName=line[1],
FirstName=line[2],
MiddleName=line[3],
Suffix=line[4],
DOB=line[5],
Gender=line[6],
SSN=line[7],
Address1=line[8],
Address2=line[9],
Zip=line[10],
MothersMaidenName=line[11],
MRN=line[12],
City=line[13],
State=line[14],
Phone=line[15],
Phone2=line[16],
Email=line[17],
Alias=line[18])
record.save()
num = num + 1
return
def run(self):
while not self.stoprequest.isSet():
#Receive and unpack message
try:
can_pkt = self.sock.recv(16)
except socket.error:
self.logger.info('Exiting can receiver loop')
self.session.commit()
self.db_session.remove()
self.logger.info("Commiting the session and clearing resources")
continue
can_id, length, x, y, z, timestamp = struct.unpack(self.FMT, can_pkt)
# This code only with real device and in debugging
if self.debug is False:
self.logger.info('can_id: %d, length: %d, x: %d, y: %d, z: %d',
can_id, length, x, y, z)
#Mask ID to hide possible flags
can_id = can_id & socket.CAN_EFF_MASK
self.logger.info('CAN id masked is %d', can_id)
#Create Record
hold_id = self.canid_holdid_dict[can_id]
if hold_id is None:
self.logger.warn('No hold found for can_id %d', can_id)
continue
record = Record(hold_id=hold_id, can_id=can_id, x=x, y=y, z=z,
timestamp=timestamp, climb_id=self.climb.id)
#Send Record to WS
socketio.emit('json', json.dumps(record.to_ws_dict()), namespace='/api/climbs')
#Save the Record in db
self.session.add(record)
def save_record(request):
if request.POST:
try:
teacher_name = request.POST['teacher_name']
grade_no = request.POST['grade_no']
dt = request.POST['date']
dt = datetime.datetime.strptime(dt, '%m-%d-%Y')
tm = request.POST['time']
tm = datetime.datetime.strptime(tm, "%I:%M%p")
timestamp = str(dt.date()) + " " + str(tm.time())
comments = request.POST['comments']
user = request.user
record = Record()
record.user = user
record.teacher_name = teacher_name
record.grade = grade_no
record.timestamp = timestamp
record.district = user.first_name
record.comments = comments
record.save()
messages.success(request, 'Data saved successfully!')
return HttpResponseRedirect("/cal/save_record/")
except Exception as err:
messages.error(request, 'Error saving data ({0})'.format(str(err)))
return HttpResponseRedirect("/cal/save_record/")
else:
query = Record.objects.filter(user=request.user).values()
data = []
for i in query:
obj = {}
obj['teacher_name'] = i['teacher_name']
obj['grade'] = i['grade']
obj['timestamp'] = str(i['timestamp']).split('+')[0]
data.append(obj)
return render(request, "calendar.html", {'message': ' ', 'data': data})
def post(self, item_id):
"""在一个条目下创建一条记录"""
remark = request.form.get('remark', '')
item = get_or_raise(ItemM, id=item_id)
start = datetime.now()
record = RecordM(start=start, remark=remark)
record.item = item
db.session.add(record)
db.session.commit()
return {'status': 201, 'message': 'Created', 'data': record}, 201
def create_resource_record(req_record_data):
"""
create a new resource object based on the request parameters
:param req_record_data:
:return:
"""
validation, error = new_record_validator(req_record_data)
if error:
return jsonify({'error': error})
record_type = req_record_data.get('type')
validation, error = DNS_TYPES[record_type](req_record_data)
if error:
return jsonify({"error": error})
record_id = req_record_data.get('zone_id')
resource_record = Domain.query.filter_by(id=record_id).first()
new_record = Record()
new_record.domain_id = record_id
if req_record_data.get('name'):
new_record.name = req_record_data.get(
"name") + '.' + resource_record.name
else:
new_record.name = resource_record.name
new_record.type = record_type
new_record.content = req_record_data.get("content")
new_record.ttl = req_record_data.get("ttl") or 3600
new_record.prio = req_record_data.get("priority") or None
db.session.add(new_record)
db.session.commit()
return jsonify({"status": "ok"})
def test_calculation_of_item(self):
"""
api: /category/<int:category_id>/calculation
methods: get: 获取一个分类下的每个条目的记录的时间总和（秒）
"""
item = Item.query.first()
record = Record(start=datetime(2019, 1, 10, 6, 0, 0),
finish=datetime(2019, 1, 10, 7, 0, 0))
record.item = item
db.session.add(record)
db.session.commit()
res = self.client.get(BASE_URL + '/category/1/calculation').get_json()
self.assertEqual(200, res['status'])
self.assertEqual(3600, res['data'][0]['value'])
def setUp(self):
super().setUp()
category = Category(name='test_category')
item = Item(name='test_item')
item.category = category
record_1 = Record(start=datetime(2019, 1, 10, 6, 0, 0),
finish=datetime(2019, 1, 10, 7, 0, 0),
remark='test_record_1')
record_2 = Record(start=datetime(2019, 1, 11, 6, 0, 0),
finish=datetime(2019, 1, 11, 7, 0, 0),
remark='test_record_2')
item.records = [record_1, record_2]
db.session.add(item)
db.session.commit()
def add_record(user, file=None, path=None):
if path:
get = requests.get(path)
if get.status_code == 200:
data = get.content
f = BytesIO()
f.write(data)
file = InMemoryUploadedFile(f, None,
path.split('/')[-1], None, len(data),
None, None)
new_record = Record(user=user, file=file, filename=file.name)
new_record.save()
process.process_classify(new_record.id, str(new_record.file))
process.process_facerecog(new_record.id, str(new_record.file))
return new_record.pk
def delete_all():
if request.method == 'POST':
id = request.form.get('ids')
print('id=', id)
id = id.split(',')
if 'on' in id:
id.remove('on')
if '' in id:
id.remove('')
print('id=', id)
for i in id:
book = Book.query.get_or_404(i)
db.session.delete(book)
# 每删除一个book，即将book信息添加record表中
r = {
'assetnumber': book.booknumber,
'brand': '',
'product': book.bookname,
'depotname': '图书管理'
}
record = Record(**r)
db.session.add(record)
db.session.commit()
flash('删除成功', 'success')
return redirect_back('book.index')
def borrow():
form = BorrowBookForm()
if form.validate_on_submit():
if db.session.query(Card).filter(
Card.cno == form.cno.data).count() != 0:
if db.session.query(Book).filter(Book.id == form.bno.data).filter(
Book.stock > 0).count() != 0:
book = db.session.query(Book).filter(
Book.id == form.bno.data).filter(Book.stock > 0).one()
record = Record(bno=book.id,
cno=form.cno.data,
btime=datetime.utcnow(),
username=current_user.name)
try:
db.session.add(record)
db.session.commit()
book.stock = book.stock - 1
db.session.add(book)
db.session.commit()
flash(u'借书成功')
return redirect(url_for('admin.borrow'))
except:
flash(u'未知错误')
return redirect(url_for('admin.borrow'))
flash(u'卡号错误或者库存不足')
return render_template('admin/borrow.html', form=form)
def site(site_name):
form = RecordForm()
page = request.args.get('page', 1, type=int)
site=Site.query.filter_by(name=site_name).first_or_404()
if form.validate_on_submit():
site.latest_count = form.count.data
record = Record(site_id=site.id,
user_id=current_user.id,
count=form.count.data,
comments=form.comments.data)
db.session.add(record)
db.session.commit()
flash(_('Record saved'))
return redirect(url_for('main.site', site_name=site.name))
cameras = Camera.query.filter_by(site_id=site.id).paginate(
page, current_app.config['ITEMS_PER_PAGE'], False)
next_url = url_for('site', page=cameras.next_num) \
if cameras.has_next else None
prev_url = url_for('site', page=cameras.prev_num) \
if cameras.has_prev else None
return render_template('site.html',
title=site.name,
site=site,
cameras=cameras.items,
form=form,
prev_url=prev_url,
next_url=next_url)
def patient_profile(unit_id):
unit = Unit.query.get(unit_id)
form = RecordForm()
if form.validate_on_submit():
record = Record(complaint=form.complaint.data,
history=form.history.data,
results=form.results.data,
assessment=form.assessment.data,
plan=form.plan.data,
prescriptions=form.prescriptions.data,
demographics=form.demographics.data,
body=form.body.data,
owner=unit,
author=current_user)
db.session.add(record)
db.session.commit()
flash('新的病历记录已经被提交', category='info')
return redirect(url_for('patient_profile', unit_id=unit.id))
page = request.args.get('page', 1, type=int)
pagination = unit.records.order_by(Record.timestamp.desc()).paginate(
page, app.config['UNITS_PER_PAGE'], False)
records = pagination.items
if unit.owner == current_user or current_user.can('ADMINISTER') == True:
return render_template('patient_profile.html',
page=page,
pagination=pagination,
records=records,
form=form,
unit=unit)
else:
return render_template('patient_profile.html',
page=page,
pagination=pagination,
records=records,
unit=unit)
def delete_all(name):
depot = Depot.query.filter_by(name=name).first()
template_id = depot.template_id
if request.method == 'POST':
all_id = request.form.get('ids')
all_id = all_id.split(',')
if '' in all_id:
all_id.remove('')
if 'on' in all_id:
all_id.remove('on')
print("all_id=", all_id)
all_id = list(map(int, all_id))
for i in all_id:
if template_id == 1:
cmp = T1.query.filter(and_(T1.name == name,
T1.id == i)).first()
elif template_id == 2:
cmp = T2.query.filter(and_(T2.name == name,
T2.id == i)).first()
elif template_id == 3:
cmp = T3.query.filter(and_(T3.name == name,
T3.id == i)).first()
db.session.delete(cmp)
# 删除cmp时，将cmp的信息写入record表中
r = {
'assetnumber': cmp.assetnumber,
'brand': cmp.product_name,
'product': cmp.model_name,
'depotname': depot.name
}
record = Record(**r)
db.session.add(record)
db.session.commit()
return redirect_back()
def test_good(self):
app.app.config['WTF_CSRF_ENABLED'] = False
with app.app.test_request_context('/'):
r = Record(**test_record)
form = EditForm(MultiDict(r.record))
result = form.validate()
self.assertEqual(result, True)
def getCarAttrApi():
try:
if request.method == 'POST':
username = request.form.get('username')
image = request.form.get('image')
key_token=request.form.get('key_token')
else:
username = request.args.get('username')
image = request.args.get('image')
key_token=request.form.get('key_token')
if username == None:
return formattingData1(username=-1, msg='未登录')
# 此处保留有关页码的问题，暂时不做处理
if key_token == None:
return formattingData1(username=-1,msg='key_token值错误')
user = User.query.filter_by(username=username).first()
if(user.count_access > 500):
return formattingData1(username=-1,msg='此用户接口使用次数已达上限')
if(user.key_token != key_token):
return formattingData1(username=-1,msg='用户名和key_token值不符合')
user.count_access+=1
db.session.commit()#调用接口次数加一
string=CarTeller.car_attribute_tell(image)
time1=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
url1="jpg/"+username+time1+".jpg"
url1=url1.replace(" ","1")
record = Record(username=username, msg="属性检测一次:" + string, time=time1,url=url1)
db.session.add(record)
db.session.commit()
imgdata(image,username,time1)
return formattingData1(username=username, msg=string)
except KeyError as e:
return formattingData1(username=-1, msg='Sorry,get num failed.')
def get_record():
try:
#首先验证是否有username参数
username = request.args.get('username')
session = request.args.get('session')
if username == None:
return formattingData1(username=-1, msg='未输入用户名')
elif session == None:
return formattingData1(username=-1, msg='未登录')
#此处保留有关页码的问题，暂时不做处理
print("用户名"+username+"session"+session)
print('键的数量'+str(len(session_dict)))
if username not in session_dict.keys():
print("session数据消失")
print("sessname"+str(session_dict[username]))
#现在进行验证session
if username not in session_dict.keys():
return formattingData1(username=-1, msg='未登录')
if session_dict[username] != int(session):
return formattingData1(username=-1, msg='被挤下线啦')
record = Record.query.filter_by(username=username).all()
my_record = []
for item in record:
r = Record(item.username, item.msg, item.time,item.url)
my_record.append(r)
str_json = json.dumps(my_record, default=Record.serialize, ensure_ascii=False)
str_json = "{\"code\":0,\"msg\":\"\",\"count\":" + str(len(my_record)) + ",\"data\":" + str_json + "}"
return str_json
except KeyError as e:
return formattingData1(username=-1, msg='Sorry,get record failed.')
def record_add():
form = AddRecordForm()
form.unit_id.choices = [
(u.id, u.name)
for u in Unit.query.order_by(Unit.timestamp.desc()).all()
]
if form.validate_on_submit():
record = Record(complaint=form.complaint.data,
history=form.history.data,
results=form.results.data,
assessment=form.assessment.data,
plan=form.plan.data,
prescriptions=form.prescriptions.data,
demographics=form.demographics.data,
body=form.body.data,
owner=Unit.query.get(form.unit_id.data),
author=current_user)
db.session.add(record)
db.session.commit()
flash('新的病历记录已经被提交', category='info')
return redirect_back()
page = request.args.get('page', 1, type=int)
pagination = Record.query.order_by(Record.timestamp.desc()).paginate(
page, app.config['RECORDS_PER_PAGE_ADD'], False)
records = pagination.items
return render_template('add_record.html',
title='Add Record',
form=form,
records=records,
pagination=pagination)
def face():
form = FaceForm(
MultiDict({
**request.form.to_dict(),
**request.files.to_dict()
}))
if form.validate():
# 获取图片
img = cv2.imdecode(np.fromstring(form.img.data.read(), np.uint8),
cv2.IMREAD_COLOR)
if img is None:
return make_response(jsonify({'msg': '上传图片出错'}), 400)
sid = face_model.compare(img)
if sid is None:
return make_response(jsonify({'msg': '未注册'}), 400)
# 获取人员信息
staff = Staff.query.filter_by(id=sid).first()
if len(staff.record) == 0 or valid_interval(staff.record[-1]):
record = Record(sid=sid,
device=form.device.data,
time=datetime.now())
try:
db.session.add(record)
db.session.commit()
return make_response(jsonify(StaffViewModel(staff).info), 200)
except Exception:
db.session.rollback()
return make_response(jsonify({'msg': '写入数据库失败'}), 400)
else:
return make_response(jsonify({'msg': '参数验证失败'}), 400)
return make_response(jsonify({'msg': '未知错误'}), 400)
def create_record():
mbid = request.args.get('mbid')
data = None
form = RecordForm()
if mbid:
r = requests.get(
'http://ws.audioscrobbler.com/2.0/'
'?method=album.getinfo'
'&mbid=' + mbid +
'&api_key=' + app.config['LAST_API_KEY'] +
'&format=json'
)
data = r.json()
form.album.data = data['album']['name']
form.artist.data = data['album']['artist']
if form.validate_on_submit():
record = Record(
artist=form.artist.data,
album=form.album.data,
year_released=form.year_released.data,
year_printed=form.year_printed.data,
condition=form.condition.data,
user_id=current_user.id,
mbid=mbid
)
db.session.add(record)
db.session.commit()
flash('Record created!')
return redirect(url_for('records'))
return render_template('create_record.html', form=form, data=data, title='Create')
def record(request):
if request.method == 'GET':
return render(request, 'app/record.html', {})
else:
result_dict = {}
member_id = request.session['user_id']
name = request.POST['name'] #점검자
address = request.POST['address'] #건물주소
buildingname = request.POST['buildingname'] #건물이름
own = request.POST['own'] #건물주
num1 = request.POST['num1']
num2 = request.POST['num2']
num3 = request.POST['num3']
num4 = request.POST['num4']
num5 = request.POST['num5']
num6 = request.POST['num6']
num7 = request.POST['num7']
num8 = request.POST['num8']
num9 = request.POST['num9']
num10 = request.POST['num10']
if member_id == '' or address == '' or name == '' or buildingname == '' or own == '' or num1 == '' or num2 == '' or num3 == '' or num4 == '' or num5 == '' or num6 == '' or num7 == '' or num8 == '' or num9 == '' or num10 == '':
result_dict['result'] = '공백은 사용할 수 없습니다.'
return JsonResponse(result_dict)
else:
try:
record = Record(
member_id=member_id,
address=address,
name=name,
buildingname=buildingname,
own=own,
num1=num1,
num2=num2,
num3=num3,
num4=num4,
num5=num5,
num6=num6,
num7=num7,
num8=num8,
num9=num9,
num10=num10,
)
record.save()
result_dict['result'] = '등록완료'
except:
pass
return JsonResponse(result_dict)
def test_record_from_int_value(self):
"""
Test that a record instance's value is returned as float even if
it was passed an int
"""
data = {"value": 42}
result = Record(**data)
self.assertEqual(result.value, float(data["value"]))
def fake_records(count=50):
items = Item.query.all()
times = [fake.date_time_this_year() for _ in range(count * 2)]
times.sort(reverse=True)
while True:
try:
for _ in range(count):
record = Record(start=times.pop(),
finish=times.pop(),
remark=fake.sentence())
record.item = random.choice(items)
db.session.add(record)
db.session.commit()
break
except IntegrityError:
db.session.rollback()
continue
def test_record(database):
recorder = Recorder(uid="RecorderX")
parameters = RecordingParameters(uid="ParametersX", duration=100.0)
series = Series(uid="SeriesX",
recorder_uid=recorder.uid,
parameters_uid=parameters.uid)
database.session.add_all([recorder, parameters, series])
record = Record(uid='SuperQualityRecord',
start_time=time(),
series_uid=series.uid)
database.session.add(record)
database.session.commit()
assert record.uid == 'SuperQualityRecord'
assert record.created_at is not None
assert record.start_time < time()
assert record.stop_time == record.start_time + parameters.duration
assert record.uploaded_at is None
assert record.series == series
assert record.label is None
assert not record.is_uploaded()
assert record.filepath is not None
assert not record.filepath.exists()
# fake upload file
record.filepath.parent.mkdir(parents=True, exist_ok=True)
record.filepath.touch()
record.uploaded_at = datetime.now()
database.session.commit()
assert record.is_uploaded()
record.filepath.unlink()
record.uploaded_at = None
database.session.commit()
assert not record.is_uploaded()
def get_my_records():
user = User.check_token(request.headers.get('Authorization').split(" ")[1])
if not user:
abort(401)
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 10, type=int), 100)
data = Record.to_collection_dict(Record.query.filter_by(
user_id=user.id), page, per_page, 'api.get_my_records')
return jsonify(data)
def test_record_no_datetime(self):
"""
Test that a record instance created without a given datetime
has one earlier or equal than dt.now()
"""
data = {"value": 10.00}
result = Record(**data)
self.assertLessEqual(dt.strptime(result.datetime, "%Y-%m-%dT%H:%M:%S"),
dt.now())
def test_record_negative_value(self):
"""
Test that a record instance can be created with a negative value
"""
data = {
"value": -2.43,
}
result = Record(**data)
self.assertEqual(result.value, data["value"])
def exec_borrow():
reader_id = request.form['user']
if int(request.form['exec']) == 1:
# 检查该读者是否借过该书且未还
result = int(db.session.execute("SELECT count(*) from records INNER JOIN readers ON records.reader_id = readers.id "
"WHERE records.book_id=:id AND records.receive_date IS NULL AND records.reader_id=:rid",
{"id": request.form['book_id'], 'rid': reader_id }).first()[0])
if result != 0:
session['message'] = '该读者已借阅过该书！'
return redirect(url_for("app.view.borrow", reader_id=reader_id))
# 检查是否有书可借
book = Book.query.filter_by(id=request.form['book_id']).first()
if book is None:
session['message'] = '馆内查无此书！'
return redirect(url_for("app.view.borrow", reader_id=reader_id))
if book.store <= 0:
record = Record.query.filter_by(book_id=book.id).order_by(Record.receive_date.desc()).first().receive_date
if record is None:
record = "无记录"
session['message'] = '库存不足！ 最后还书时间:%s' % record
return redirect(url_for("app.view.borrow", reader_id=reader_id))
record = Record(reader_id=reader_id, book_id=request.form['book_id'], admin_id=current_user.id)
book.store -= 1
db.session.add(record)
db.session.add(book)
db.session.commit()
session['message'] = '借阅成功！'
if int(request.form['exec']) == 2:
record = Record.query.filter_by(reader_id=reader_id, book_id=request.form['book_id'], receive_date=None).first()
if record is None:
session['message'] = "未找到借阅未还记录！"
return redirect(url_for("app.view.borrow", reader_id=reader_id))
book = Book.query.filter_by(id=request.form['book_id']).first()
if book is None:
session['message'] = "查无此书！"
return redirect(url_for("app.view.borrow", reader_id=reader_id))
book.store += 1
record.receive_date = datetime.now()
db.session.add(record)
db.session.add(book)
db.session.commit()
session['message'] = "还书成功！"
return redirect(url_for("app.view.borrow", reader_id=reader_id))
def test_record_no_value(self):
"""
Test that Record raises TypeError if not given a value upon creation
"""
data = {
"description": "Just a regular record",
"datetime": dt.now().isoformat(timespec="seconds")
}
with self.assertRaises(TypeError):
result = Record(**data)
def new_record():
record_data = request.get_json()
recorder = flask.g.recorder
if record_data["series_uid"] not in [s.uid for s in recorder.serieses]:
flask.abort(403, "Recorder {} does not maintain series {}".format(
recorder.uid, record_data["series_uid"]
))
if record_data["label_uid"] is not None:
get_object_or_404(Label, record_data["label_uid"])
try:
record = Record(**record_data)
db.session.add(record)
db.session.commit()
return record.to_dict()
except exc.IntegrityError as ex:
db.session.rollback()
flask.abort(400, str(ex))
except ValueError as ex:
flask.abort(400, str(ex))
def add_record(request):
if not request.user.is_authenticated():
return HttpResponse(content = '{"success":false,"msg":"NOT_LOGIN"}', content_type = 'application/json')
item = request.POST['item']
amount,category = parse_amount(item)
record = Record(user = request.user)
record.category = category
record.amount = amount
record.added_on = request.POST['date']
record.save()
record = Record.objects.get(pk = record.pk)
result = {}
result['success'] = True
result['data'] = record.clean_object
report = update_report(request.user, record.added_on)
profile = request.user.get_profile()
profile.account_balance = profile.account_balance + record.amount
profile.save()
result['report'] = report.clean_object
result['balance'] = str(profile.account_balance)
return HttpResponse(content = json.dumps(result), content_type = 'application/json')
def check_recurrence(user, request_year, request_month):
from datetime import datetime
now = datetime.now()
if request_year != now.year or request_month != now.month:
return
items = Recurrence.objects.filter(user = user)
import calendar,datetime
start_date = datetime.date(now.year, now.month, 1)
month_range = calendar.monthrange(now.year, now.month)
end_date = datetime.date(now.year, now.month, month_range[1])
added = False
for item in items:
records = Record.objects.filter(user = user, is_recurrent = True, added_on__range = (start_date, end_date), category = item.category)
if len(records) == 0 and str(request_year*100 + request_month) not in item.ignore_months:
added_on = datetime.datetime(now.year, now.month, item.day, now.hour, now.minute, now.second)
if added_on > item.origin_record.added_on and item.day <= now.day:
added = True
record = Record(user = user, is_recurrent = True, added_on = added_on, category = item.category, amount = item.amount)
record.save()
profile = user.get_profile()
profile.account_balance = profile.account_balance + record.amount
profile.save()
if added:
update_report(user, record.added_on)
