def add_note(self, note: Note):
note.id = str(uuid.uuid4())
note.created_at = datetime.datetime.now()
note.created_by = g.user_id
self.session.add(note)
self.session.commit()
return note
def _create_note(self, user):
note_data = {
'title': self.request.get('title'),
'content': self.request.get('content')
}
item_titles = self.request.get('checklist_items').split(',')
Note.create_note(user, note_data, item_titles)
def get(self):
data = {
'title': 'Admin | 便签',
'notes': Note.get_all_note(),
'tags': Note.get_all_tag()
}
self.render('admin/admin_note.html', **data)
async def add(self, message: discord.Message, params: list):
"""
Adds a note to the database using the provided parameters.
:param message: Instance of the discord message that triggered the error. (discord.Message)
:param params: Message parameters/note attributes. (List[String])
"""
if len(params) != 5:
await self.error(message, 'Add command takes exactly 3 parameters!')
return
title = params[2]
body = params[3]
tags = params[4].split(',')
note = Note(
title=title,
body=body,
tags=tags,
author=message.author.name
)
try:
note = self.note_repository.create(note)
except Exception as e:
await self.error(message, str(e))
return
response = note.to_json()
await message.author.send(response)
def delete(request):
form = request.json()
note_id = int(form['id'])
Note.delete(id=note_id)
m = dict(message='删除成功', )
return json_response(m)
def get(self, tag):
data = {
'title': 'Tag | 便签',
'notes': Note.get_note_by_tag(tag),
'tags': Note.get_all_tag()
}
self.render('purecss_ui/note.html', **data)
def get(self):
data = {
'title': 'Note | 便签',
'notes': Note.note(),
'tags': Note.get_all_tag()
}
self.render('purecss_ui/note.html', **data)
def get(self, tag):
data = {
'title': 'Tag | 便签',
'tag': tag,
'notes': Note.get_note_by_tag(tag),
'tags': Note.get_all_tag()
}
self.render('admin/admin_note.html', **data)
def get(self):
data = {
'title': 'Note | 便签',
'notes': Note.note(),
'tags': Note.get_all_tag()
}
self.render('purecss_ui/note.html', **data)
def get(self, tag):
data = {
'title': 'Tag | 便签',
'notes': Note.get_note_by_tag(tag),
'tags': Note.get_all_tag()
}
self.render('purecss_ui/note.html', **data)
def overtone_ranges(self, n, accuracy):
key = "%d%f" % (n, accuracy)
if not key in self.overtone_range_cache:
ranges = []
for note in self.notes:
low_note = Note(note)
low_note.set_octave(2)
ranges += low_note.overtone_ranges(n, accuracy)
self.overtone_range_cache[key] = FrequencyRange.simplify(ranges)
return self.overtone_range_cache[key]
def note_save():
user_token = auth_verify(dict(request.headers))
body = request.json
body.update({"owner_id": user_token["id"]})
validated = NoteSchema().load(body)
if validated.errors:
abort(400, validated.errors)
noteData = Note(**validated.data)
noteData.save()
return parse_response(validated.data)
def post(self):
form = AddNoteForm(self.request.arguments)
if form.validate:
title = form.data.get('title', '')
tag = form.data.get('tag', '')
hide = form.data.get('hide', '')
content = form.data.get('content', '')
Note.create_note(title, tag, hide, content)
self.redirect(self.reverse_url('admin-note'))
else:
self.return_status(400, form.errors)
def load_data(db_handler):
""" Method to generate random notes to fill our database and test endpoints"""
from random import seed
from random import random
seed(1)
new_notes = []
for i in range(1,10):
new_notes.append({
'title': str(i) + str(random()),
'content': 'Lorem ipsum' + str(i),
'active': True,
'created_by':"Cristhian" + str(i),
'created_at': date.today(),
'edited_at':date.today(),
})
new_notes.append(
{
"active": False,
"content": "Jesenia",
"edited_at": "2019-10-24",
"title": "Jesenia La chica de al lado",
"created_by": "Cristhian1",
"created_at": "2019-10-24"
})
new_notes.append(
{
"active": False,
"title": "La vida de los numeros",
"content": "Lorem ipsum y los numeros de la muerte",
"edited_at": "2019-10-25",
"created_by": "Jesenia",
"created_at": "2019-10-24"
})
Note.insert_many(new_notes).execute()
User(name="Cristhian", email="*****@*****.**",
password=b'$2b$12$U/QjtHt/j0xRT4r8Hx3fOe93EssM6M0iiUaQJOrTd64RXbxvhw6Ii').save()
def best_accuracy_for(self, note):
note = Note(note).clean_note()
if not str(note) in self.best_accuracies:
note_range = self.get_range_for(note)
peaks_to_check = [
index for index in self.peaks if index in note_range
]
if len(peaks_to_check) == 0:
self.best_accuracies[str(note)] = 50
else:
self.best_accuracies[str(note)] = np.min([
np.abs(Note(self.xf[i]).accuracy) for i in peaks_to_check
])
return self.best_accuracies[str(note)]
def post_notes():
requesData = request.json
schema = NoteSchema(many=True)
noteObjects = schema.load(requesData).data
with sql_database.atomic():
Note.bulk_create(noteObjects)
jsonNotes = schema.dumps(noteObjects)
response.headers['Content-Type'] = 'application/json'
return jsonNotes.data
def on_action_duplicate_note_triggered(self):
if self.line_edit_subject.isModified(
) or self.text_edit_editor.document().isModified():
self.on_action_save_note_triggered()
note = Note(account_id=self._account_manager.get_account(
self._account_manager.list_accounts()[0]).id,
title='{} (Copy)'.format(self.line_edit_subject.text()),
html_content=self.text_edit_editor.toHtml())
note.create()
self.__load_note_to_list(note.account_id, note.file)
self.list_widget_notelist.setCurrentRow(0)
class Notes:
__note = Note()
__today = datetime.date(datetime.now())
def getAll(self, order_by='id', order_method='DESC'):
notes_data = self.__note.find('id', '>', '0', order_by, order_method)
notes = []
for note in notes_data:
if parse(note['time']).date() == self.__today:
note['time'] = datetime.strptime(
note['time'], "%Y-%j-%d %H:%M:%S").strftime('%I:%M %p')
notes.append(note)
return notes
def create(self, title, time):
time = parse(time)
note = {
'title': title,
'time': time,
}
id = self.__note.create(note)
note['id'] = id
from libs.alarm import notes
notes.append(note)
def delete(self, id):
self.__note.delete({'key': 'id', 'value': id})
from libs.alarm import notes
for i in range(len(notes)):
if notes[i]['id'] == int(id):
del notes[i]
break
def get_member_notes(member: discord.Member,
guild: discord.Guild) -> [Note] or None:
""" Get a guild members notes. Usually called after !notes is invoked in a guild
Args:
member (discord.Member): The member retrieving their notes
guild (discord.Guild): The guild that the notes are attached to
Returns:
[Note or None]: The Notes that the user has saved, loaded into Note's
"""
try:
db_coll = db.get_collection(str(guild.id))
except Exception:
logger.exception("No guild ID given")
return
res = db_coll.find_one({"user_id": member.id})
if not res:
return None
else:
notes = [Note(details) for details in res["notes"]]
return notes
def add(gid):
form = request.form
print('!!note add form', form)
u = current_user()
g = Group.get_one_by(group_id=gid)
t = Note.inserNote(form, u, g)
return t
def post(self):
#geting data from fron-end
json_data = request.get_json(force=True)
if not json_data:
return {'message': 'No input data provided'}, 400
# Validate and deserialize input
data, errors = note_schema.load(json_data)
if errors:
return errors, 422
user_id = get_jwt_identity()
notebook = Notebook.query.filter_by(id=data['notebook_id']).first()
if not notebook:
return {'message': 'Category does not exist'}, 400
notebook.modified_date = datetime.now(pytz.utc)
#matching new note data by fields
new_note = Note(title=data['title'],
body=data['body'],
creation_date=datetime.now(pytz.utc),
modified_date=datetime.now(pytz.utc),
notebook_id=data['notebook_id'],
user_id=user_id)
#submitting note to database
db.session.add(new_note)
db.session.commit()
#get json from pyton object
result = note_schema.dump(new_note).data
return {"status": 'success', 'data': result}, 201
def _on_root_selected(self):
notes = list(Note.select().order_by(self.header_panel.sort_option))
self.header_panel.set_title('所有笔记')
self.header_panel.set_count(len(notes))
self._load(notes)
self._notebook = None
self.header_panel.reset_search_bar()
def average_intensity_for(self, note):
note = Note(note).clean_note()
if not str(note) in self.average_intensities:
self.average_intensities[str(note)] = np.mean(
[self.fft_out[i] for i in self.get_range_for(note)])
return self.average_intensities[str(note)]
def draw_note(self, note, labelfunc=str, octaves=True, color='k'):
note = Note(note)
frets = self.find_note(note, octaves=octaves)
if octaves:
accuracy = int(np.round(note.accuracy))
if accuracy > 0:
label = "%s + %.0f" % (note.note, accuracy)
elif accuracy < 0:
label = "%s %.0f" % (note.note, accuracy)
else:
label = note.note
else:
label = str(note)
X = []
Y = []
for fret in frets:
plt.text(fret.xpos,
fret.ypos,
labelfunc(fret),
horizontalalignment='center',
verticalalignment='center',
fontsize=12)
X.append(fret.xpos)
Y.append(fret.ypos)
plt.scatter(X,
Y,
s=300,
linewidth=2,
label=label,
facecolors='white',
edgecolors=color)
def select_note(self, min_increase=0.2, n=4, accuracy=30):
if not hasattr(self, 'notes'):
self.notes = []
if not hasattr(self, 'explained_percent'):
self.explained_percent = 0
if not hasattr(self, 'frequency_ranges'):
self.frequency_ranges = []
best_value = 0
best_note = 'E2'
for key in self.note_integrals:
if self.note_integrals[key] > best_value:
best_value = self.note_integrals[key]
best_note = key
value_increase = best_value - self.explained_percent
if value_increase > min_increase:
print(best_note)
print(best_value)
best_note = Note(best_note)
self.notes.append(best_note)
self.explained_percent = best_value
return value_increase
else:
return 0
def decompose(self, n=4, accuracy=30):
if not hasattr(self, 'notes'):
self.notes = []
if not hasattr(self, 'frequency_ranges'):
self.frequency_ranges = []
self.note_integrals = {}
self.note_counts = {}
total_integral = 0
all_notes = Note.range('E2', 'B5')
self.total_integral = sum(self.fft_out)
for note in all_notes:
self.note_integrals[str(note)] = 0
ranges = [*note.overtone_ranges(n, accuracy)]
for chosen_note in self.notes:
ranges = [*ranges, *chosen_note.overtone_ranges(n, accuracy)]
ranges = FrequencyRange.simplify(ranges)
for note_range in ranges:
if note_range.start > self.fft_max:
break
start = self.get_index_of_frequency(note_range.start)
start = np.max([0, start])
end = self.get_index_of_frequency(note_range.end)
end = np.min([self.fft_count, end])
self.note_counts[str(note)] = end - start
self.note_integrals[str(note)] += sum(
list(self.fft_out[start:end]))
for key in self.note_integrals:
self.note_integrals[key] = (
self.note_integrals[key] /
self.total_integral) - (self.note_counts[key] / self.fft_count)
def get(self, op, note_id):
"""
Handles HHTP GET requests.
"""
try:
##################
#root = Note(content="Well, the way they make shows is, they make one show.")
#root.put()
#n1 = Note(content="That show's called a pilot.",parentNote=root)
#n1.put()
#n2 = Note(content="Then they show that show to the people who make shows...",parentNote=n1)
#n2.put()
#n3 = Note(content="... and on the strength of that one show they decide if they're going to make more shows. Some pilots get picked and become television programs. Some don't, become nothing. She starred in one of the ones that became nothing.",parentNote=n2)
#n3.put()
#n4 = Note(content="The path of the righteous man is beset on all sides by the iniquities of the selfish and the tyranny of evil men.", parentNote=root, position=1)
#n4.put()
##################
if op == 'list':
try:
note = Note.get(note_id)
except datastore_errors.BadKeyError:
note = None
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(self.list_notes(note))
else:
self.response.clear()
self.response.set_status(501)
self.response.out.write("Unknown operation.")
except DeadlineExceededError:
self.response.clear()
self.response.set_status(500)
self.response.out.write("This operation could not be completed in time...")
def get_value(self, index):
frequency = self.parent.xf[index]
# below 10 hz we honestly don't care and the pitch of the note is hard to identify
if frequency < 10:
return 0
return np.abs(Note(frequency).accuracy)
def render_word(self, word_content=None, error=None, back_to_word=None):
note_record = Note.get_note(
word_content["word"]) if word_content else None
self.render("word.html",
word=word_content,
error=error,
back_to_word=back_to_word,
note_record=note_record.format_response())
def add_notes(self, notes_dicts):
for note_dict in notes_dicts:
note = None
if note_dict.has_key('id'):
notes = filter(lambda x: x.id == note_dict['id'], self.notes)
if len(notes) > 0:
note = notes[0]
else:
note = Note(self, note_dict['text'])
self.notes.append(note)
db.session.add(note)
else:
note = Note(self, note_dict['text'])
self.notes.append(note)
db.session.add(note)
note.text = note_dict['text']
db.session.commit()
def get_range_for(self, note):
note = Note(note).clean_note()
if not str(note) in self.ranges:
start = self.get_index_of_frequency((note - .5).frequency)
end = self.get_index_of_frequency((note + .5).frequency)
self.ranges[str(note)] = range(start, end)
return self.ranges[str(note)]
def add_notes(self, notes_dicts):
for note_dict in notes_dicts:
note = None
if note_dict.has_key('id'):
notes = filter(lambda x: x.id == note_dict['id'], self.notes)
if len(notes) > 0:
note = notes[0]
else:
note = Note(self, note_dict['text'])
self.notes.append(note)
db.session.add(note)
else:
note = Note(self, note_dict['text'])
self.notes.append(note)
db.session.add(note)
note.text = note_dict['text']
db.session.commit()
def get_accuracy(self, note):
if not hasattr(self, 'root'):
return 0
note = Note(note)
accuracy = (note / self.root) % 1
return np.min([accuracy, 1 - accuracy])
def add(request):
form = request.json()
u = current_user(request)
form['user_id'] = u.id
n = Note.new(form)
return json_response(n.json())
def post(self):
user = users.get_current_user()
if user is None:
self.error(401)
note_data = json.loads(self.request.body)
note = Note.create_note(user, note_data, note_data['checklist_items'].split(','))
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(note.to_json())
def create_note(self, content, parent=None, after=None):
"""
Creates a new note, saves it to datastore and returns newly
created note as JSON string. If `after` parameter is given,
new note will have position property set to be greater than
the one specified.
"""
if after:
position = after.position + 1
else:
position = 0
notes = Note.all().filter("position >=", position).filter("parentNote ==", parent).order("position").fetch(None)
cnt = 1
for n in notes:
n.position = position + cnt
n.put()
cnt = cnt + 1
note = Note(content=content, parentNote=parent, position=position)
note.put()
return json.dumps(note.to_dict())
def get(self):
user = users.get_current_user()
notes = Note.owner_fetch(user)
if user is not None:
template_context = {
'json': json,
'user': self._user_to_dict(user),
'notes': map(lambda note: note.to_dict(), notes)
}
self.response.out.write(
self._render_template('main.html', template_context))
else:
login_url = users.create_login_url(self.request.uri)
self.redirect(login_url)
def list_notes(self, parent=None, list_deleted=False):
"""
Returns all notes (with sub-notes) as a JSON string. If parent is
given returns all notes starting from the parent. If `list_deleted`
is True returns only deleted notes.
"""
if parent:
return json.dumps(parent.to_dict())
else:
notes = Note.all().filter('parentNote ==', None).filter('deleted ==', list_deleted).order('position').fetch(None)
res = []
for n in notes:
res.append(n.to_dict())
return json.dumps(res)
def move_note(self, note, parent, after=None):
"""
Moves a note to a new parent.
"""
if after:
position = after.position + 1
else:
position = 0
notes = Note.all().filter("position >=", position).filter("parentNote ==", parent).order("position").fetch(None)
cnt = 1
for n in notes:
n.position = position + cnt
n.put()
cnt = cnt + 1
note.parentNote = parent
note.position = position
note.put()
return json.dumps(note.to_dict())
def post(self, op, note_id):
"""
Handles HHTP POST requests.
"""
try:
try:
if db.Key(note_id).namespace() != namespace_manager.get_namespace():
self.response.clear()
self.response.set_status(401)
self.response.out.write("You are not authorised to access this resource.")
return
except datastore_errors.BadKeyError:
pass
if op == 'create':
pid = self.request.get("parentId")
afterId = self.request.get("afterNote")
content = self.request.get("content")
try:
parent = Note.get(pid)
except datastore_errors.BadKeyError:
parent = None
try:
after = Note.get(afterId)
except datastore_errors.BadKeyError:
after = None
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(self.create_note(content, parent, after))
elif op == 'update':
content = self.request.get("content")
try:
note = Note.get(note_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(self.update_note(note, content))
except datastore_errors.BadKeyError:
self.response.clear()
self.response.set_status(404)
self.response.out.write("Note not found.")
elif op == 'delete':
try:
note = Note.get(note_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(self.delete_note(note))
except datastore_errors.BadKeyError:
self.response.clear()
self.response.set_status(404)
self.response.out.write("Note not found.")
elif op == 'restore':
try:
note = Note.get(note_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(self.restore_note(note))
except datastore_errors.BadKeyError:
self.response.clear()
self.response.set_status(404)
self.response.out.write("Note not found.")
elif op == 'move':
pid = self.request.get("parentId")
afterId = self.request.get("afterNote")
try:
parent = Note.get(pid)
except datastore_errors.BadKeyError:
parent = None
try:
after = Note.get(afterId)
except datastore_errors.BadKeyError:
after = None
try:
note = Note.get(note_id)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(self.move_note(note, parent, after))
except datastore_errors.BadKeyError:
self.response.clear()
self.response.set_status(404)
self.response.out.write("Note not found.")
else:
self.response.clear()
self.response.set_status(501)
self.response.out.write("Unknown operation.")
except DeadlineExceededError:
self.response.clear()
self.response.set_status(500)
self.response.out.write("This operation could not be completed in time...")
except CapabilityDisabledError:
self.response.clear()
self.response.set_status(503)
self.response.out.write("Scheduled maintenance. Application is in read-only mode.")
