def search(input=""):
search_form = SearchForm()
key_number_list = []
keys = []
key_obj = Key()
if "," in input:
key_number_list = input.split(",")
for num in key_number_list:
key_list = key_obj.get_key_by_key_number(int(num))
for key in key_list:
keys.append(key)
else:
key = key_obj.get_key_by_key_number(int(input))
for k in key:
keys.append(k)
if request.method == "POST":
for key in keys:
if key.available == True:
selected_key = key_obj.query.get(key.id)
selected_key.available = False
db.session.add(selected_key)
new_transaction = Transaction(user=current_user, key_id=key.id, time_stamp=datetime.datetime.now() + timedelta(hours=3))
db.session.add(new_transaction)
db.session.commit()
flash("ALL keys taken")
return render_template("result_page.html", keys=keys, search_form=search_form)
if request.method == "GET":
return render_template("result_page.html", keys=keys, search_form=search_form)
def create_users():
for user in users:
User.create(user['firstname'], user['lastname'], user['rfid_card'],
user['admin'])
for key in keys:
Key.create(key['room'], key['rfid_chip'])
def test_note_names__non_standard_flats(self):
names = Key('C♭ minor').note_names
expected = ('C♭', 'D♭', 'E♭♭', 'F♭', 'G♭', 'A♭♭', 'B♭♭')
self.assertEqual(expected, names)
names = Key('F♭ minor').note_names
expected = ('F♭', 'G♭', 'A♭♭', 'B♭♭', 'C♭', 'D♭♭', 'E♭♭')
self.assertEqual(expected, names)
def test_note_names__sharps(self):
names = Key('C♯').note_names
expected = ('C♯', 'D♯', 'E♯', 'F♯', 'G♯', 'A♯', 'B♯')
self.assertEqual(expected, names)
names = Key('F♯').note_names
expected = ('F♯', 'G♯', 'A♯', 'B', 'C♯', 'D♯', 'E♯')
self.assertEqual(expected, names)
def test_note_names__non_standard_sharps(self):
names = Key('B♯ minor').note_names
expected = ('B♯', 'C♯♯', 'D♯', 'E♯', 'F♯♯', 'G♯', 'A♯')
self.assertEqual(expected, names)
names = Key('E♯ minor').note_names
expected = ('E♯', 'F♯♯', 'G♯', 'A♯', 'B♯', 'C♯', 'D♯')
self.assertEqual(expected, names)
def test_generate_notes(self):
key_notes = Key('C# minor').scale.notes
expected = (C_sharp, D_sharp, E, F_sharp, G_sharp, A, B)
self.assertEqual(expected, key_notes)
key_notes = Key('C#').scale.notes
expected = (C_sharp, D_sharp, E_sharp, F_sharp, G_sharp, A_sharp, B_sharp)
self.assertEqual(expected, key_notes)
def test_init__invalid(self):
with self.assertRaises(InvalidQualityError):
Key('A foo')
with self.assertRaises(InvalidQualityError):
Key('A major quack a doodle')
with self.assertRaises(InvalidQualityError):
Key('A 4000')
def test_key(self):
# Divisible by 4: C major
text = 'This is a sentence'
key = Game(text).key
self.assertEqual(Key('C'), key)
# Divisible by 2: A minor
text = 'It was a good sentence'
key = Game(text).key
self.assertEqual(Key('Am'), key)
def test_init(self):
a_minor = Key('A minor')
self.assertEqual(A, a_minor.tonic)
a_minor = Key('Am')
self.assertEqual(A, a_minor.tonic)
a_minor = Key('A min')
self.assertEqual(A, a_minor.tonic)
a_minor = Key('Amin')
self.assertEqual(A, a_minor.tonic)
def test_init(self):
a_major = Key('A')
self.assertEqual(A, a_major.tonic)
a_major = Key('A major')
self.assertEqual(A, a_major.tonic)
a_major = Key('A maj')
self.assertEqual(A, a_major.tonic)
a_major = Key('Amaj')
self.assertEqual(A, a_major.tonic)
def __parse_key(self, buf, algo, created, usage, expiry):
fingerprint_match = key_fingerprint_regex.match(buf.readline())
if not fingerprint_match:
return None
fingerprint = fingerprint_match.group(1)
uid_match = uid_regex.match(buf.readline())
if not uid_match:
return None
name = uid_match.group(1)
desc = uid_match.group(2)
email = uid_match.group(3)
key = Key(fingerprint=fingerprint,
algo=algo,
created=created,
usage=usage,
expiry=expiry,
email=email,
name=name,
description=desc)
return key
def test_types(self):
key_c = Key('C')
self.assertEqual(IonianScale, key_c.ionian_mode.base_scale)
self.assertTrue(isinstance(key_c.ionian_mode, Mode))
c_ionian_mode = Mode(C, IonianScale)
self.assertEqual(IonianScale, c_ionian_mode.base_scale)
self.assertTrue(isinstance(c_ionian_mode, Mode))
def test_note_names__natural(self):
names = Key('A').note_names
expected = ('A', 'B', 'C♯', 'D', 'E', 'F♯', 'G♯')
self.assertEqual(expected, names)
names = Key('B').note_names
expected = ('B', 'C♯', 'D♯', 'E', 'F♯', 'G♯', 'A♯')
self.assertEqual(expected, names)
names = Key('C').note_names
expected = ('C', 'D', 'E', 'F', 'G', 'A', 'B')
self.assertEqual(expected, names)
names = Key('D').note_names
expected = ('D', 'E', 'F♯', 'G', 'A', 'B', 'C♯')
self.assertEqual(expected, names)
names = Key('E').note_names
expected = ('E', 'F♯', 'G♯', 'A', 'B', 'C♯', 'D♯')
self.assertEqual(expected, names)
names = Key('F').note_names
expected = ('F', 'G', 'A', 'B♭', 'C', 'D', 'E')
self.assertEqual(expected, names)
names = Key('G').note_names
expected = ('G', 'A', 'B', 'C', 'D', 'E', 'F♯')
self.assertEqual(expected, names)
def test_notes__natural__minors(self):
names = Key('A minor').note_names
expected = ('A', 'B', 'C', 'D', 'E', 'F', 'G')
self.assertEqual(expected, names)
names = Key('B minor').note_names
expected = ('B', 'C♯', 'D', 'E', 'F♯', 'G', 'A')
self.assertEqual(expected, names)
names = Key('C minor').note_names
expected = ('C', 'D', 'E♭', 'F', 'G', 'A♭', 'B♭')
self.assertEqual(expected, names)
names = Key('D minor').note_names
expected = ('D', 'E', 'F', 'G', 'A', 'B♭', 'C')
self.assertEqual(expected, names)
names = Key('E minor').note_names
expected = ('E', 'F♯', 'G', 'A', 'B', 'C', 'D')
self.assertEqual(expected, names)
names = Key('F minor').note_names
expected = ('F', 'G', 'A♭', 'B♭', 'C', 'D♭', 'E♭')
self.assertEqual(expected, names)
names = Key('G minor').note_names
expected = ('G', 'A', 'B♭', 'C', 'D', 'E♭', 'F')
self.assertEqual(expected, names)
def create_user():
db.create_all()
db.session.add(
User(id=0,
name='myuser',
password='******',
roles=["authenticated"]))
db.session.add(Key(id=0, key='azerty', roles=["admin"]))
db.session.commit()
def test_keys_with_natural_tonic(self):
self.assert_key_modes_are_correct(Key('C'))
self.assert_key_modes_are_correct(Key('D'))
self.assert_key_modes_are_correct(Key('E'))
self.assert_key_modes_are_correct(Key('F'))
self.assert_key_modes_are_correct(Key('G'))
self.assert_key_modes_are_correct(Key('A'))
self.assert_key_modes_are_correct(Key('B'))
def test_keys_with_sharp_tonic(self):
self.assert_key_modes_are_correct(Key('C#m'))
self.assert_key_modes_are_correct(Key('D#m'))
self.assert_key_modes_are_correct(Key('E#m'))
self.assert_key_modes_are_correct(Key('F#m'))
self.assert_key_modes_are_correct(Key('G#m'))
self.assert_key_modes_are_correct(Key('A#m'))
self.assert_key_modes_are_correct(Key('B#m'))
def test_keys_with_flat_tonic(self):
self.assert_key_modes_are_correct(Key('Cbm'))
self.assert_key_modes_are_correct(Key('Dbm'))
self.assert_key_modes_are_correct(Key('Ebm'))
self.assert_key_modes_are_correct(Key('Fbm'))
self.assert_key_modes_are_correct(Key('Gbm'))
self.assert_key_modes_are_correct(Key('Abm'))
self.assert_key_modes_are_correct(Key('Bbm'))
def test_keys_with_natural_tonic(self):
self.assert_key_modes_are_correct(Key('Cm'))
self.assert_key_modes_are_correct(Key('Dm'))
self.assert_key_modes_are_correct(Key('Em'))
self.assert_key_modes_are_correct(Key('Fm'))
self.assert_key_modes_are_correct(Key('Gm'))
self.assert_key_modes_are_correct(Key('Am'))
self.assert_key_modes_are_correct(Key('Bm'))
def generate_rsa_keys():
key = RSA.generate(2048)
try:
key_model = Key(device_id=request.get_json().get("device_id"),
p_key=key.publickey().export_key().decode("UTF-8"),
pr_key=key.exportKey().decode("UTF-8"))
db.session.add(key_model)
db.session.commit()
return "Success", 200
except Exception as ServerError:
return {"error": str(ServerError).split("\n")[0]}, 500
def test_note_names__flat(self):
names = Key('A♭ minor').note_names
expected = ('A♭', 'B♭', 'C♭', 'D♭', 'E♭', 'F♭', 'G♭')
self.assertEqual(expected, names)
names = Key('B♭ minor').note_names
expected = ('B♭', 'C', 'D♭', 'E♭', 'F', 'G♭', 'A♭')
self.assertEqual(expected, names)
names = Key('D♭ minor').note_names
expected = ('D♭', 'E♭', 'F♭', 'G♭', 'A♭', 'B♭♭', 'C♭')
# D♭, E♭, F♭, G♭, A♭, B♭♭, and C♭.
self.assertEqual(expected, names)
names = Key('E♭ minor').note_names
expected = ('E♭', 'F', 'G♭', 'A♭', 'B♭', 'C♭', 'D♭')
self.assertEqual(expected, names)
names = Key('G♭ minor').note_names
expected = ('G♭', 'A♭', 'B♭♭', 'C♭', 'D♭', 'E♭♭', 'F♭')
self.assertEqual(expected, names)
def change_key():
form = ChangeKeyForm()
if request.method == 'POST':
if form.validate_on_submit():
key = Key.get_by_id(1)
key.key = generate_password_hash(form.ckey.data)
key.save()
flash('<script>alert("密码修改成功")</script>')
return redirect(url_for('home'))
else:
flash('<script>alert("密码修改失败，请确保两次输入一致")</script>')
return render_template('change_key.html', form=form)
def generate_and_store_random_key_pair(is_refresh_token_key=False):
key_generator = KeyGenerator()
key_file_writer = KeyFileWriter(key_generator)
key = Key(is_refresh_token_key=is_refresh_token_key)
try:
db.session.add(key)
db.session.commit()
key_file_writer.write_keys_to_file(str(key.id))
except:
db.session.rollback()
def create_key():
form = CreateKeyForm()
search_form = SearchForm()
company_list = current_user.list_all_company()
# Remove Aurio Head company from the list
for company in company_list:
if company.name == "Aurio Head":
company_list.remove(company)
if request.method == "POST":
key_obj = Key()
key_obj.key_number = int(form.key_number.data)
key_obj.available = True
check_list = key_obj.get_all_key(current_user.company.id)
if current_user.role == 3:
key_obj.company_id = int(form.selected_company.data)
elif current_user.role == 2:
key_obj.company_id = current_user.company_id
db.session.add(key_obj)
db.session.commit()
flash("Key have been created")
return render_template("create_key.html", form=form, search_form=search_form, list=company_list)
else:
if current_user.role == 1:
flash("You have no permission")
return redirect(url_for("main"))
else:
return render_template("create_key.html", form=form, search_form=search_form, list=company_list)
def test_chords(self):
text = 'This is a sentence'
game = Game(text)
chord_this, chord_is, chord_a, chord_sentence = game.chords
# First chord should be the key's tonic
self.assertEqual(Key('C'), game.key)
self.assertEqual((C, E, G), chord_this)
# Remaining chords should be calculated from letters
self.assertEqual((D, G), chord_is)
self.assertEqual((C, ), chord_a)
self.assertEqual((G, B, A, E), chord_sentence)
def login():
if request.method == 'GET' and session.get('logged_in'):
return redirect_back('home')
form = KeyForm()
if request.method == 'POST' and form.validate_on_submit():
key = form.key.data
if check_password_hash(Key.get_by_id(1).key, key):
session['logged_in'] = True
flash('<script>alert("登陆认证成功")</script>')
return redirect(url_for('home'))
else:
flash('<script>alert("密码验证失败")</script>')
return render_template('login.html', form=form)
def add_url(url: str):
"""
Populate url info to a database
Represent long operation that can takes significant amount of time
What's why it's moved to a celery task
:param url: link to a XML file
:return: {'id': <id of created Url in DB>}
"""
xml_dict = parse_xml_file(url)
url_object = Url(url=xml_dict['url'],
processed=bool(not xml_dict['error_text']),
error=xml_dict['error_text'])
url_object.keys = [Key(value=key) for key in xml_dict['keys']]
s.add(url_object)
s.commit()
# sleep(20) # uncomment this, if you want to test *real* async :)
return {'id': url_object.id}
def paint_key_name(frame, key: Key, text_margin: int, offset: List = None):
center_point = key.get_center_point()
if center_point == (-1, -1):
return
draw_point = get_drawing_point_for_point_with_offset(center_point, offset)
# Draw shadow
cv2.putText(frame, key.name,
(draw_point[0] + text_margin, draw_point[1] - text_margin),
Config.font_family, Config.key_name_font_scale, (0, 0, 0),
round(Config.key_name_font_thickness * 1.4), Config.line_type)
# Draw text
cv2.putText(frame, key.name,
(draw_point[0] + text_margin, draw_point[1] - text_margin),
Config.font_family, Config.key_name_font_scale, key.color,
Config.key_name_font_thickness, Config.line_type)
def load_keys():
if Config.calibrating:
keys.clear()
if len(keys) > 0:
return
# Generate keys
key_amount = Config.key_amount_to_calibrate
for i in range(0, key_amount):
color_diff = (i + 1) / key_amount * 6.3
color_diff %= 1
key_color = (255, 255 * color_diff, 255 - 255 * color_diff)
note_name = Key.note_base_names[i % 12] + str(i // 12)
keys.append(Key(note_name, color=key_color))
def get(self, key_id=None):
'''
This would be a good candidate for caching, since most likely the keys will often be requested
unless an application would cache the keys themselves to validate payloads
'''
active_keys = Key.get_n_most_recent_keys(3)
if key_id is None:
response = {'keys': []}
for key in active_keys:
response['keys'].append(
{key.id: KeyFileReader.get_public_key(str(key.id))})
else:
if key_id not in [key.id for key in active_keys]:
return jsonify({'message':
f'Key with id {key_id} not found.'}), 404
response = {key_id: KeyFileReader.get_public_key(str(key_id))}
return jsonify(response)
def get(self, request, available=None, taken=None, history=None):
check_history = UserKeyLink.get_all_operations()
if not check_history['errors'] or check_history['warnings']:
history = [i for i in check_history['data'] if i.date_returned]
check_taken_keys = UserKeyLink.get_all_operations()
if not check_taken_keys['errors'] or check_taken_keys['warnings']:
taken = [
i for i in check_taken_keys['data'] if not i.date_returned
]
check_available_keys = Key.get_available_keys()
if not check_available_keys['errors'] or check_available_keys[
'warnings']:
available = check_available_keys['data']
return render(request, 'keys/index.html', {
'available': available,
'taken': taken,
'history': history
})
def test_helper_assertion_function(self):
"""
The helper function iterates through each mode, shifting the expected
set of notes over 1 degree. For example, from Ionian to Dorian, the
expected notes for C Minor shift from:
('C', 'D', 'E♭', 'F', 'G', 'A♭', 'B♭')
to:
('D', 'E♭', 'F', 'G', 'A♭', 'B♭'. 'C')
This test asserts that we are doing so correctly in the helper function.
"""
modal_scales = self.assert_key_modes_are_correct(Key('Cm'))
expected = [
('C', 'D', 'E♭', 'F', 'G', 'A♭', 'B♭'),
('D', 'E♭', 'F', 'G', 'A♭', 'B♭', 'C'),
('E♭', 'F', 'G', 'A♭', 'B♭', 'C', 'D'),
('F', 'G', 'A♭', 'B♭', 'C', 'D', 'E♭'),
('G', 'A♭', 'B♭', 'C', 'D', 'E♭', 'F'),
('A♭', 'B♭', 'C', 'D', 'E♭', 'F', 'G'),
('B♭', 'C', 'D', 'E♭', 'F', 'G', 'A♭'),
]
self.assertEqual(expected, modal_scales)
def gen_new_key(request):
key = Key()
key.value = request.POST.get("answer", None)
if key.value:
key.save()
return HttpResponse("Ok")
