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