def restore_note(orm, user, note_id, historic, d_time=None): LOG.info("Restoring note %d", note_id) d_time = historic and d_time or None note, note_v, d_time = get_deleted_entity( orm, Note, Note_v, "note_id", note_id, "note_v_id", d_time) d_time = historic and d_time or None if note: LOG.warning("Note %d already exists.", note_id) return note if not note_v: LOG.error( "Cannot restore note %d because no recently " "deleted versions exist.", note_id) return None LOG.info("deleted time: %s", d_time) note = Note( note_v.text, note_v.source, user, note_v.public) note.note_id = note_v.note_id orm.add(note) return note
def post(self): user_id, user = self.get_user() if not user: self.redirect('/') return title = self.request.get('note-title') text = self.request.get('note-text') dt = datetime.datetime.now() logging.info('%s\n%s\n%s', title, text, dt) if not title or not text: msg = ( 'You must enter a title and some text to create a new note.' ) data = { 'page_title': 'Blank Note', 'user': user, 'error_msg': msg } self.render('error.html', **data) return new_note = Note( user=user.key, submit_date=dt, title=title, text=text, ) new_note.put() self.redirect('/notes')
def addDroppedNote(self, path): note = Note(); note.modificationDate = note.creationDate = datetime.date.today() note.basket = RuntimeSettings.currentBasket note.text = path note.save() self.reload()
def deserialize_notes(self, string): board_export = self.string_to_array(string) notes_export = board_export['notes'] notes = [] for note_export in notes_export: note = Note() note.from_export(note_export) notes.append(note) return notes
def add_note(): if not request.is_json: return BadRequest('Missing JSON request') user_email = request.json.get('email') title = request.json.get('title') note_text = request.json.get('text') user = User.objects(email=user_email).first() if user is None: raise BadRequest("Not Found") note = Note(title=title, text=note_text, user=user.id) note.save() return jsonify(note=note.serialize)
def get(self): # req_json = json.loads(self.request.body) # user_email = req_json[IDENTIFIER_USER_EMAIL] user_email = self.request.get(IDENTIFIER_USER_EMAIL) # apt_name = req_json[IDENTIFIER_APT_NAME] apt_name = self.request.get(IDENTIFIER_APT_NAME) # description = req_json[IDENTIFIER_DESCRIPTION_NAME] description = self.request.get(IDENTIFIER_DESCRIPTION_NAME) apt_lst = Apartment.query(Apartment.apt_name == apt_name).fetch() cur_apt = None for apt in apt_lst: if user_email in apt.user_email_lst: cur_apt = apt if cur_apt == None: response = {} response[ 'error'] = 'the apt: ' + apt_name + ' is not available for user: '******'error'] = 'we dont have notebook for the apt: ' + apt_name return self.respond(**response) cur_note_book = cur_note_book_lst[0] note_id = uuid.uuid4() note = Note(id=str(note_id), description=description, author_email=user_email, notebook_id=cur_note_book_id) cur_note_book.note_id_lst.append(str(note_id)) cur_note_book.put() note.put() self.respond(note_id=str(note_id), notebook_id=cur_note_book_id, status="Success")
def test_update(): conn = connect() store = NoteStore(conn) note = Note(None, 'title', 'content') store.create(note) note.title = "Better Title" note.content = "Better Content" store.update(note) from_db = store.fetch(note.note_id) assert from_db.title == "Better Title" assert from_db.content == "Better Content"
def get_notes(sort_by='priority', fmt=None): notes = [] indices = rds.lrange('notes', 0, -1) app.logger.debug("found %d note IDs in index" % len(indices)) for index in indices: notes.append(Note(**rds.hgetall(index))) notes = Note.sort(notes, sort_by=sort_by) if fmt == 'json': notes = { 'notes': Note.dict_repr(notes) } return notes
def createNotes(self): fileList = {"NotesMD": ("README.md", "data/credits.md", "data/about.md") } for basket, notes in fileList.iteritems(): dbBasket = Basket() dbBasket.basketName = basket dbBasket.creationDate = dbBasket.modificationDate = datetime.date.today() dbBasket.save() for note in notes: dbNote = Note() dbNote.basket = dbBasket dbNote.creationDate = dbNote.modificationDate = datetime.date.today() dbNote.text = open(note).read() dbNote.save()
def get(self): apt_name = self.request.get(IDENTIFIER_APT_NAME) user_email = self.request.get(IDENTIFIER_USER_EMAIL) apt_lst = Apartment.query(Apartment.apt_name == apt_name).fetch() # print "called: " + user_email + ", " + apt_name cur_apt = None for apt in apt_lst: if user_email in apt.user_email_lst: cur_apt = apt cur_notebook_lst = NoteBook.query( NoteBook.notebook_id == cur_apt.notebook_id).fetch() if len(cur_notebook_lst) == 0: response = {} response['error'] = 'we dont have notebook for the apt: ' + apt_name return self.respond(**response) cur_notebook = cur_notebook_lst[0] retList = [] for noteid in cur_notebook.note_id_lst: note_lst = Note.query(Note.id == noteid).fetch() cur_note = note_lst[0] ret_note = {} ret_note['author'] = cur_note.author_email ret_note['description'] = cur_note.description date = str(cur_note.date) ret_note['last_edit_date'] = date retList.append(ret_note) self.respond(AllNoteLst = retList, status="Success")
def get(self): # req_json = json.loads(self.request.body) # user_email = req_json[IDENTIFIER_USER_EMAIL] user_email = self.request.get(IDENTIFIER_USER_EMAIL) # note_id = req_json[IDENTIFIER_NOTE_ID] note_id = self.request.get(IDENTIFIER_NOTE_ID) # new_description = req_json[IDENTIFIER_NEW_DESCRIPTION_NAME] new_description = self.request.get(IDENTIFIER_NEW_DESCRIPTION_NAME) cur_note_lst = Note.query(Note.id == note_id).fetch() if len(cur_note_lst) == 0: response = {} response['error'] = 'the note with id : ' + note_id + ' is valid' return self.respond(**response) cur_note = cur_note_lst[0] if user_email != cur_note.author_email: response = {} response['error'] = 'you cannot edit this note' return self.respond(**response) cur_note.description = new_description cur_note.put() self.respond(status="Success")
def create_note_reply(user_id, doc_id, created_at, body, parent_id, fname, lname): """Reply to a note.""" # figure out x and y pos # tz = pytz.timezone('America/Los_Angeles') # created_at = datetime.now(tz) color_check = check_prev_note_color(user_id, doc_id) if color_check: color = color_check else: color = '#C2D6C4' note = Note( user_id=user_id, doc_id=doc_id, parent_id=parent_id, created_at=created_at, body=body, # x_pos = x_pos, # y_pos = y_pos, fname=fname, lname=lname, color=color) db.session.add(note) db.session.commit() return {'note': note, 'color': color}
def get(self): # req_json = json.loads(self.request.body) # note_id = req_json[IDENTIFIER_NOTE_ID] note_id = self.request.get(IDENTIFIER_NOTE_ID) # user_email = req_json[IDENTIFIER_USER_EMAIL] user_email = self.request.get(IDENTIFIER_USER_EMAIL) # description = req_json[IDENTIFIER_DESCRIPTION_NAME] description = self.request.get(IDENTIFIER_DESCRIPTION_NAME) reply_id = uuid.uuid4() notes = Note.query(Note.id == note_id).fetch() note = notes[0] user_lst = User.query(User.user_email == user_email).fetch() user = user_lst[0] new_reply = Reply(author_email = user_email, note_id = str(note_id), reply_id = str(reply_id), description = description, nick_name = user.nick_name ) new_reply.put() note.reply_id_lst.append(str(reply_id)) note.put() self.respond(reply_id = str(reply_id), status="Success")
def alert(self, view, frame, message): #print message m = re.search("^(\w+):([^_]+)_(\d+)(_(.*))?", message) if (m != None): action = m.group(1) id = m.group(3) #print "Action", action, " id", id if (action == "EDIT"): note = Note.get(Note.id==id) self.editNote(note) if (action == "ADDTAG"): self.addTag(id, m.group(5)) if (action == "REMOVETAG"): self.removeTag(id, m.group(5)) if (action == "ADDNOTE"): self.newNote(None) pass if (action == "ADDBASKET"): self.addBasket(m.group(2)) if (action == "ADDDROPPEDNOTE"): self.addDroppedNote(message[int(m.start(5)):]) if (action == "SELECTBASKET"): self.selectBasket(m.group(5)) if (action == "DELETENOTE"): self.deleteNote(id) if (action == "SEARCH_TEXT"): self.searchText(m.group(5)) return True else: return False
def create_note(teacher_id, student_id, note_created_at, note_content): """Creates a new teacher note record""" # Allows querying of student by full name # instead of querying by hybrid attribute # student_id = db.session.query(Student.student_id)\ # .filter( # func.concat( # Student.student_fname, # ' ', # Student.student_lname # ) == note_student_name # ).first() # Only allow if student id exists # if not student_id: # return None note = Note(teacher_id=teacher_id, student_id=student_id, note_created_at=note_created_at, note_content=note_content) db.session.add(note) db.session.commit() return note
def get(self): # req_json = json.loads(self.request.body) # note_id = req_json[IDENTIFIER_NOTE_ID] note_id = self.request.get(IDENTIFIER_NOTE_ID) # user_email = req_json[IDENTIFIER_USER_EMAIL] user_email = self.request.get(IDENTIFIER_USER_EMAIL) # description = req_json[IDENTIFIER_DESCRIPTION_NAME] description = self.request.get(IDENTIFIER_DESCRIPTION_NAME) reply_id = uuid.uuid4() notes = Note.query(Note.id == note_id).fetch() note = notes[0] user_lst = User.query(User.user_email == user_email).fetch() user = user_lst[0] new_reply = Reply(author_email=user_email, note_id=str(note_id), reply_id=str(reply_id), description=description, nick_name=user.nick_name) new_reply.put() note.reply_id_lst.append(str(reply_id)) note.put() self.respond(reply_id=str(reply_id), status="Success")
def get(self): apt_name = self.request.get(IDENTIFIER_APT_NAME) user_email = self.request.get(IDENTIFIER_USER_EMAIL) apt_lst = Apartment.query(Apartment.apt_name == apt_name).fetch() # print "called: " + user_email + ", " + apt_name cur_apt = None for apt in apt_lst: if user_email in apt.user_email_lst: cur_apt = apt cur_notebook_lst = NoteBook.query( NoteBook.notebook_id == cur_apt.notebook_id).fetch() if len(cur_notebook_lst) == 0: response = {} response[ 'error'] = 'we dont have notebook for the apt: ' + apt_name return self.respond(**response) cur_notebook = cur_notebook_lst[0] retList = [] for noteid in cur_notebook.note_id_lst: note_lst = Note.query(Note.id == noteid).fetch() cur_note = note_lst[0] ret_note = {} ret_note['author'] = cur_note.author_email ret_note['description'] = cur_note.description date = str(cur_note.date) ret_note['last_edit_date'] = date retList.append(ret_note) self.respond(AllNoteLst=retList, status="Success")
def post(self, note_id=0): '''Updating the comment and redirecting back to the photo page.''' user_id, user = self.get_user() if not user: self.redirect('/') return note_id = int(note_id) note = Note.get_by_id(note_id) error, data = self._check(user, note) if error: self.render('error.html', **data) title = self.request.get('note-title') text = self.request.get('note-text') logging.info('%s\n%s', repr(title), repr(text)) if not title or not text: msg = ( 'You must enter a title and some text to create a new note.' ) data = { 'page_title': 'Blank Note', 'user': user, 'error_msg': msg } self.render('error.html', **data) return note.title = title note.text = text note.put() self.redirect('/notes')
def index(): if request.method == 'POST': form = NoteForm(request.form) if form.validate(): note = Note(unique_word_count=count_unique_word(form.text.data), short_description=form.text.data[:60], text=form.text.data) db.session.add(note) db.session.commit() flash('Заметка №({}) успешно добавлена'.format(note.id), 'success') return redirect(url_for('index')) else: flash('Пожалуйста заполните форму', 'warning') return redirect(url_for('index')) if request.method == 'GET': form = NoteForm() return render_template('index.html', title='Add Note', form=form, active_note_add=True)
def newNote(): if request.method == "POST": json = request.get_json() newNote = Note(json["sourceCode"], json["owner"], json["course_belonged"]) db.session.add(newNote) db.session.commit() return jsonify({"status": "OK"})
def test_chord(self): a = Note(100, 15, 250) b = Note(100, 11, 250) c = Note(100, 18, 250) score = Score([a, b, c]) for i in [40, 99, 101, 349, 350, 351, 450]: self.assertEquals(0, len(score.starts_at(i))) self.assertEquals(3, len(score.starts_at(100))) for i in [40, 99, 100, 101, 349, 351, 450]: self.assertEquals(0, len(score.ends_at(i))) self.assertEquals(3, len(score.ends_at(350))) for i in [50, 99, 350, 351, 450]: self.assertEquals(0, len(score.sounding_at(i))) for i in [100, 101, 349]: self.assertEquals(3, len(score.sounding_at(i)))
def store_notes(note_content, match_id, group_id): """ Store grouped notes per match """ note = Note(note_content=note_content, match_id=match_id, group_id=group_id) db.session.add(note) db.session.commit()
def setUp(self): """ Create a validator and add one note to it. Note(delay=100, height=15, duration=100) """ self.the_note = Note(delay=100, height=15, duration=100) score = Score([self.the_note]) self.validator = Validator(score, margin=10) self.validator.add_reference_note(self.the_note)
def get(self): # req_json = json.loads(self.request.body) # user_email = req_json[IDENTIFIER_USER_EMAIL] user_email = self.request.get(IDENTIFIER_USER_EMAIL) # apt_name = req_json[IDENTIFIER_APT_NAME] apt_name = self.request.get(IDENTIFIER_APT_NAME) # description = req_json[IDENTIFIER_DESCRIPTION_NAME] description = self.request.get(IDENTIFIER_DESCRIPTION_NAME) apt_lst = Apartment.query(Apartment.apt_name == apt_name).fetch() cur_apt = None for apt in apt_lst: if user_email in apt.user_email_lst: cur_apt = apt if cur_apt == None: response = {} response['error'] = 'the apt: ' + apt_name + ' is not available for user: '******'error'] = 'we dont have notebook for the apt: ' + apt_name return self.respond(**response) cur_note_book = cur_note_book_lst[0] note_id = uuid.uuid4() note = Note(id = str(note_id), description = description, author_email = user_email, notebook_id = cur_note_book_id) cur_note_book.note_id_lst.append(str(note_id)) cur_note_book.put() note.put() self.respond(note_id = str(note_id), notebook_id = cur_note_book_id, status="Success")
def add_note(): title = request.json['title'] description = request.json['description'] user_id = request.json['user_id'] new_note = Note(title, description, user_id) db.session.add(new_note) db.session.commit() return note_schema.jsonify(new_note)
def get(self): user_id, user = self.get_user() data = { #'page_title': 'Monthly Photographs 2013', 'photos': self.random_images(4), 'user': user, 'competitions': self.competitions_in_progress(), 'comments': self.recent_comments(), 'results': self.recent_results(), 'notes': Note.recent_notes(), } self.render('home.html', **data)
def _render_template(self, message=None): """Render the main page template.""" # Query the DB for entries: notes_query = Note.all() notes_query.filter('public =', True) notes_query.order('-date') notes = notes_query.run() template_values = {'notes': notes} template = jinja_environment.get_template('templates/index.html') self.response.out.write(template.render(template_values))
def test_interval(self): a = Note(100, 15, 200) b = Note(200, 11, 200) c = Note(300, 18, 200) score = Score([a, b, c]) for i in [40, 99, 101, 199, 201, 299, 301, 400, 500]: self.assertEquals(0, len(score.starts_at(i))) for i in [100, 200, 300]: self.assertEquals(1, len(score.starts_at(i))) for i in [40, 99, 100, 101, 200, 201, 299, 301, 499]: self.assertEquals(0, len(score.ends_at(i))) for i in [300, 400, 500]: self.assertEquals(1, len(score.ends_at(i))) for i in [50, 99, 500]: self.assertEquals(0, len(score.sounding_at(i))) for i in [100, 101, 199, 400, 499]: self.assertEquals(1, len(score.sounding_at(i))) for i in [200, 201, 299, 300, 301, 399]: self.assertEquals(2, len(score.sounding_at(i)))
def _handle_timeline_notification(self, data): """Handle timeline notification.""" for user_action in data.get('userActions', []): if user_action.get('type') == 'LAUNCH': item = self.mirror_service.timeline().get(id=data['itemId']).execute() text = item.get('text') creatorID = data.get('userToken') creatorName = StorageByKeyName(Credentials, creatorID, 'displayName').get() # If the contributor is approved, make the entry public: makePublic = StorageByKeyName(Credentials, creatorID, 'approved').get() newNote = Note(text=text, userId=creatorID, creatorName=creatorName, public=makePublic) newNote.put() logging.info('Reply received: %s' % text) break else: logging.info( "I don't know what to do with this notification: %s", user_action)
def create_note(itinerary_id, user_id, comment, day=None): """Create and return a new note.""" note = Note(itinerary_id=itinerary_id, user_id=user_id, comment=comment, day=day) db.session.add(note) db.session.commit() return note
def add_gamer_note(self, note, command_type): """ Add a mingus note to the validator gamer events. """ # Agrega 2 eventos, NOTE_ON y NOTE_OFF delay = self.time note = Note.from_mingus_note(note, delay) if command_type == 'NOTE_ON': self.gamer_events.append(Event(Event.NOTE_ON, note.delay, note)) elif command_type == 'NOTE_OFF': self.gamer_events.append(Event(Event.NOTE_OFF, note.delay, note)) else: raise NotImplementedError
def create_note(job_applied_id, user_id, note_title, note_text, note_category, note_date_created): """create and return note """ note = Note(job_applied_id=job_applied_id, user_id=user_id, note_title=note_title, note_text=note_text, note_category=note_category, note_date_created=note_date_created) db.session.add(note) db.session.commit() return note
def post(self): """Update database when user added a note.""" if not current_user.is_active: return 'No permission.' key1 = request.form.get('key1') key2 = request.form.get('key2') new_note = Note(key1, key2) db.session.add(new_note) db.session.commit() message = 'Note added succesfully' return 'Note Added.'
def test_single_note(self): a = Note(100, 15, 250) score = Score([a]) for i in [40, 99, 101, 349, 350, 341, 450]: self.assertEquals(0, len(score.starts_at(i))) self.assertEquals(1, len(score.starts_at(100))) for i in [40, 99, 100, 101, 349, 351, 450]: self.assertEquals(0, len(score.ends_at(i))) self.assertEquals(1, len(score.ends_at(350))) for i in [50, 99, 350, 351, 450]: self.assertEquals(0, len(score.sounding_at(i))) for i in [100, 101, 349]: self.assertEquals(1, len(score.sounding_at(i)))
def update_note(id): if not request.is_json: raise BadRequest("Missing Json Request") title = request.json.get('title') text = request.json.get('text') note = Note.objects(id=id).first() """ *update_one()* Perform an atomic update on the fields of the first document matched by the query *update()* is for actual Document object update """ note.update(set__title=title, set__text=text, set__updated_at=datetime.utcnow) return jsonify({"message": "updated"}, note.serialize), 201
def post(self, note_id=0): user_id, user = self.get_user() if not user: self.redirect('/') note_id = int(note_id) note = Note.get_by_id(note_id) error, data = self._check(user, note) if error: self.render('error.html', **data) return note.key.delete() self.redirect('/notes')
def create_note(teacher_id, note_student_name, note_created_at, note_content): """Creates a new teacher note record""" # Allows querying of student by full name – Hopefull this works! student_id = session.query(Student).filter( Student.full_name == note_student_name).first() note = Note(teacher_id=teacher_id, student_id=student_id, note_created_at=note_created_at, note_content=note_content) db.session.add(note) db.session.commit() return note
def _render_template(self, message=None): """Render the user page template.""" notes_query = Note.all() notes_query.order('-date') notes_query.filter('userId =', self.userid) notes = notes_query.run() template_values = {'notes': notes} displayName = StorageByKeyName(Credentials, self.userid, 'displayName').get() template_values['displayName'] = displayName template_values['approved'] = StorageByKeyName(Credentials, self.userid, 'approved').get() template = jinja_environment.get_template('templates/contributor.html') self.response.out.write(template.render(template_values))
def make_new_attraction(): """Process new attraction and its notes.""" set_val_attraction_id() set_val_note_id() attraction_name = request.form.get('attraction_name').strip() dest_id = request.form.get('dest_id') note_contents = request.form.getlist('note[]') # list #Get wiki description wiki_content = get_wiki_description(attraction_name) if not wiki_content: wiki_content = None #Add a new attraction to db attraction = Attraction(name=attraction_name, dest_id=dest_id, description=wiki_content) db.session.add(attraction) db.session.commit() #Add notes to db if not note_contents: note_contents = [''] for note_content in note_contents: new_note = Note(content=note_content, attraction_id=attraction.attraction_id) db.session.add(new_note) db.session.commit() attraction_note_info = { 'attraction_id': attraction.attraction_id, 'name': attraction.name, 'notes': [{ 'note_id': note.note_id, 'content': note.content } for note in attraction.notes] } print "##### Developer msg ##### Attraction added:", attraction return jsonify(attraction_note_info)
def add_note(): """User can add short notes to their homepage.""" user_id = session["user_id"] if request.method == "POST": note = request.form["note"] new_note = Note(note=note, user_id=user_id) db.session.add(new_note) db.session.commit() return jsonify({"note_id": new_note.note_id, "note": new_note.note}) else: return redirect(f"/")
def addTag(self, noteId, strTag): count = Tag.select().where(Tag.tag == strTag).count() if (count == 0): dbTag = Tag() dbTag.creationDate = dbTag.modificationDate = datetime.date.today() dbTag.tag = strTag dbTag.save() else: dbTag = Tag.get(Tag.tag == strTag) note = Note.get(Note.id == noteId) noteTag = NoteTag() noteTag.note = note noteTag.tag = dbTag noteTag.creationDate = noteTag.modificationDate = datetime.date.today() noteTag.save() self.view.execute_script("notesMD.tags = " + RuntimeSettings.getTags())
def get(self): user_email = self.request.get(IDENTIFIER_USER_EMAIL) note_id = self.request.get(IDENTIFIER_NOTE_ID) cur_note_lst = Note.query(Note.id == note_id).fetch() if len(cur_note_lst) == 0: response = {} response['error'] = 'The ID is not available: ' + note_id return self.respond(**response) cur_note = cur_note_lst[0] retValue = {} retValue['author'] = cur_note.author_email retValue['last_edit_date'] = str(cur_note.date) retValue['description'] = cur_note.description self.respond(Note = retValue, status="Success")
def get(self): user_email = self.request.get(IDENTIFIER_USER_EMAIL) note_id = self.request.get(IDENTIFIER_NOTE_ID) cur_note_lst = Note.query(Note.id == note_id).fetch() if len(cur_note_lst) == 0: response = {} response['error'] = 'The ID is not available: ' + note_id return self.respond(**response) cur_note = cur_note_lst[0] retValue = {} retValue['author'] = cur_note.author_email retValue['last_edit_date'] = str(cur_note.date) retValue['description'] = cur_note.description self.respond(Note=retValue, status="Success")
def SSVParse(filename, resolution): """ Parse a SSV (?). Resolution must be integer. """ g = open(filename) notes = [] playing = [None] * 128 for line in g: parts = line.split() delay = int(float(parts[0]) * 1000) / resolution * resolution height = int(parts[1]) speed = int(parts[2]) if speed > 0: playing[height] = delay else: if playing[height] is not None: note = Note(playing[height], height, delay - playing[height]) notes.append(note) return Score(notes)
def get(self): note_id = self.request.get(IDENTIFIER_NOTE_ID) notes = Note.query(Note.id == note_id).fetch() note = notes[0] replys = note.getAllreply() reply_lst = [] sorted_replys = sorted(replys, key=lambda reply: reply.date) for reply in sorted_replys: cur_reply = {} cur_reply['author'] = reply.nick_name cur_reply['author_email'] = reply.author_email cur_reply['description'] = reply.description cur_reply['reply_id'] = str(reply.reply_id) cur_reply['date'] = str(reply.date) reply_lst.append(cur_reply) self.respond(reply_lst=reply_lst, status="Success")
def test_shift(self): a = Note(100, 15, 250) shift = 100 score = Score([copy(a)]) score.shift_all_notes(shift) for i in [140, 199, 201, 449, 450, 451, 550]: self.assertEquals(0, len(score.starts_at(i))) self.assertEquals(1, len(score.starts_at(200))) for i in [140, 199, 200, 201, 449, 451, 550]: self.assertEquals(0, len(score.ends_at(i))) self.assertEquals(1, len(score.ends_at(450))) for i in [150, 199, 450, 451, 550]: self.assertEquals(0, len(score.sounding_at(i))) for i in [200, 201, 449]: self.assertEquals(1, len(score.sounding_at(i))) notes = score.starts_at(200) for n in notes: self.assertEquals(n.delay, a.delay + shift)
def get(self, note_id=0): user_id, user = self.get_user() if not user: self.redirect('/') return note_id = int(note_id) note = Note.get_by_id(note_id) error, data = self._check(user, note) if error: self.render('error.html', **data) return data = { 'page_title': 'Delete Note', 'user': user, 'note': note, } self.render('note-delete.html', **data)
def get(self): note_id = self.request.get(IDENTIFIER_NOTE_ID) notes = Note.query(Note.id == note_id).fetch() note = notes[0] replys = note.getAllreply() reply_lst = [] sorted_replys = sorted(replys, key=lambda reply:reply.date) for reply in sorted_replys: cur_reply = {} cur_reply['author'] = reply.nick_name cur_reply['author_email'] = reply.author_email cur_reply['description'] = reply.description cur_reply['reply_id'] = str(reply.reply_id) cur_reply['date'] = str(reply.date) reply_lst.append(cur_reply) self.respond(reply_lst = reply_lst, status="Success")
def get(self): user_id, user = self.get_user() start = self.request.get('start') logging.info('start: %s', start) if not start: start = 0 else: start = int(start) if start > 1000000: start = 0 if start == 0: before = 0 after = 10 else: before = start - 10 after = start + 10 notes = list(Note.recent_notes(10, start)) more_old = '' if len(notes) == 10 else 'disabled' more_new = '' if start > 0 else 'disabled' data = { 'page_title': 'Notes', 'user': user, 'user_id': user_id, 'notes': notes, 'before': before, 'after': after, 'more_old': more_old, 'more_new': more_new, } self.render('notes.html', **data)
def deleteNote(self, id): note = Note.get(Note.id == id) note.delete_instance() for noteTag in NoteTag.select().where(NoteTag.note == id): noteTag.delete_instance() self.reload()
def get_note(id): note = Note.objects(id=id).first() if not note: raise NotFound("Note not found") return jsonify(note.serialize)
def post(self): if not (self.auth and self.auth.search_permission and self.auth.domain_write_permission == '*'): self.info( 403, message= '"key" URL parameter is either missing, invalid or ' 'lacks required permissions. The key\'s repo must be "*", ' 'search_permission must be True, and it must have write ' 'permission with domain name "*".', style='plain') return body = self.request.body_file.read() doc = xml.dom.minidom.parseString(body) message_text = self.get_element_text(doc, 'message_text') receiver_phone_number = self.get_element_text( doc, 'receiver_phone_number') if message_text is None: self.info( 400, message='message_text element is required.', style='plain') return if receiver_phone_number is None: self.info( 400, message='receiver_phone_number element is required.', style='plain') return repo = ( self.config.sms_number_to_repo and self.config.sms_number_to_repo.get(receiver_phone_number)) if not repo: self.info( 400, message= 'The given receiver_phone_number is not found in ' 'sms_number_to_repo config.', style='plain') return query_lang = None query_action = None match = None for lang, action, regex in HandleSMS.QUERY_PATTERNS: match = re.search(regex, message_text.strip(), re.I) if match: query_lang = lang query_action = action break if query_lang: # Use the language for the following calls of _(). django_setup.activate(query_lang) responses = [] if query_action == 'search': query_string = match.group(1).strip() query = TextQuery(query_string) persons = indexing.search(repo, query, HandleSMS.MAX_RESULTS) if persons: for person in persons: responses.append(self.render_person(person)) else: responses.append( _('No results found for: %(query)s') % {'query': query_string}) responses.append( _('More at: %(url)s') % {'url': 'google.org/personfinder/%s?ui=light' % repo}) responses.append( _('All data entered in Person Finder is available to the ' 'public and usable by anyone. Google does not review or ' 'verify the accuracy of this data ' 'google.org/personfinder/global/tos')) elif self.config.enable_sms_record_input and query_action == 'add': name_string = match.group(1).strip() person = Person.create_original( repo, entry_date=utils.get_utcnow(), full_name=name_string, family_name='', given_name='') person.update_index(['old', 'new']) note = Note.create_original( repo, entry_date=utils.get_utcnow(), source_date=utils.get_utcnow(), person_record_id=person.record_id, author_name=name_string, author_made_contact=True, status='is_note_author', text=message_text) db.put(note) model.UserActionLog.put_new('add', note, copy_properties=False) person.update_from_note(note) db.put(person) model.UserActionLog.put_new('add', person, copy_properties=False) responses.append(_('Added a record for: %(person_name)s') % {'person_name': name_string}) else: usage_str = 'Usage: "Search John"' if self.config.enable_sms_record_input: usage_str += ' OR "I am John"' responses.append(usage_str) # Convert the response into ASCII because the SMS pipeline doesn't # support UTF-8. # e.g., It removes diacritics such as "ú" -> "u". # This seems acceptable for Spanish, but may not be for other # languages. ascii_response = unidecode(u' ## '.join(responses)) self.response.headers['Content-Type'] = 'application/xml; charset=utf-8' self.write( '<?xml version="1.0" encoding="utf-8"?>\n' '<response>\n' ' <message_text>%s</message_text>\n' '</response>\n' % django.utils.html.escape(ascii_response))
def newNote(self, webview): note = Note(); note.creationDate = datetime.date.today() self.editNote(note)
def parseNote(self): note = Note() flags = self.readByte() if flags & 32: note.type = self.readByte() if note.type == 2: note.tied = True elif note.type == 3: note.dead = True if flags & 1: note.duration = self.readByte() note.nuplet = self.readByte() if flags & 16: note.dynamic = self.readByte() else: note.dynamic = 6 if flags & 32: note.fret = self.readByte() if flags & 128: note.lfinger = self.readByte() note.rfinger = self.readByte() if flags & 8: self.parseNoteEffect(note) return note
def get(self): logging.info('stats calculator...starting') # create a UserStat object for all Users in the db users = list(User.query().fetch()) data = dict( (user.key.id(), UserStats(user=user.key)) for user in users ) for user in users: user_stat = data[user.key.id()] user_stat.logins = user.login_count user_stat.logouts = user.logout_count user_stat.bio = 1 if user.bio else 0 for photo in Photo.query().fetch(): user_id = photo.user.id() user_stat = data[user_id] if photo.competition is None: user_stat.extra_photos += 1 else: if photo.competition.get().status != COMPLETED: # not interested in competition photos for incomplete # competitions continue user_stat.comp_photos += 1 user_stat.total_points += photo.total_score if photo.position == 1: user_stat.first_place += 1 user_stat.medals += 1 elif photo.position == 2: user_stat.second_place += 1 user_stat.medals += 1 elif photo.position == 3: user_stat.third_place += 1 user_stat.medals += 1 completed_comp_count = Competition.count() for user_stat in data.values(): if user_stat.comp_photos == completed_comp_count: user_stat.all_comps = 1 for comment in Comment.query().fetch(): # give data[comment.user.id()].comments_give += 1 # receive receiver = comment.photo.get().user.id() data[receiver].comments_receive += 1 for score in Scores.query().fetch(): receiver = score.photo.get().user.id() if score.score == 10: # give 10 data[score.user_from.id()].score_10_give += 1 # receive 10 data[receiver].score_10_receive += 1 elif score.score == 0: # give 0 data[score.user_from.id()].score_0_give += 1 # receive 0 data[receiver].score_0_recieve += 1 for note in Note.query().fetch(): data[note.user.id()].notes += 1 # is this person a GIVER for user in data.values(): if user.comments_give > user.comments_receive: user.giver += 1 if user.score_10_give > user.score_10_receive: user.giver += 1 # last place finishers self._last_positions(data) self._photo_with_most_comments(data) self._photo_with_high_score(data) self._houses(data) self._most(data, 'comments_give') self._most(data, 'comments_receive') self._most(data, 'notes') self._most(data, 'logins') self._most(data, 'logouts') self._most(data, 'medals') self._most(data, 'first_place') self._most(data, 'second_place') self._most(data, 'third_place') self._most(data, 'last_place') UserStats.delete_all() for stat in data.values(): stat.put() logging.info(data) logging.info('stats calculator...finished')
def post(self): if not (self.auth and self.auth.search_permission and self.auth.domain_write_permission == '*'): self.info( 403, message= '"key" URL parameter is either missing, invalid or ' 'lacks required permissions. The key\'s repo must be "*", ' 'search_permission must be True, and it must have write ' 'permission.', style='plain') return body = self.request.body_file.read() doc = xml.dom.minidom.parseString(body) message_text = self.get_element_text(doc, 'message_text') receiver_phone_number = self.get_element_text( doc, 'receiver_phone_number') if message_text is None: self.info( 400, message='message_text element is required.', style='plain') return if receiver_phone_number is None: self.info( 400, message='receiver_phone_number element is required.', style='plain') return repo = ( self.config.sms_number_to_repo and self.config.sms_number_to_repo.get(receiver_phone_number)) if not repo: self.info( 400, message= 'The given receiver_phone_number is not found in ' 'sms_number_to_repo config.', style='plain') return responses = [] search_m = re.search(r'^search\s+(.+)$', message_text.strip(), re.I) add_self_m = re.search(r'^i am\s+(.+)$', message_text.strip(), re.I) if search_m: query_string = search_m.group(1).strip() query = TextQuery(query_string) persons = indexing.search(repo, query, HandleSMS.MAX_RESULTS) if persons: for person in persons: responses.append(self.render_person(person)) else: responses.append('No results found for: %s' % query_string) responses.append( 'More at: google.org/personfinder/%s?ui=light' % repo) responses.append( 'All data entered in Person Finder is available to the public ' 'and usable by anyone. Google does not review or verify the ' 'accuracy of this data google.org/personfinder/global/tos.html') elif self.config.enable_sms_record_input and add_self_m: name_string = add_self_m.group(1).strip() person = Person.create_original( repo, entry_date=utils.get_utcnow(), full_name=name_string, family_name='', given_name='') person.update_index(['old', 'new']) note = Note.create_original( repo, entry_date=utils.get_utcnow(), source_date=utils.get_utcnow(), person_record_id=person.record_id, author_name=name_string, author_made_contact=True, status='is_note_author', text=message_text) db.put(note) model.UserActionLog.put_new('add', note, copy_properties=False) person.update_from_note(note) db.put(person) model.UserActionLog.put_new('add', person, copy_properties=False) responses.append('Added record for found person: %s' % name_string) else: usage_str = 'Usage: "Search John"' if self.config.enable_sms_record_input: usage_str += ' OR "I am John"' responses.append(usage_str) self.response.headers['Content-Type'] = 'application/xml' self.write( '<?xml version="1.0" encoding="utf-8"?>\n' '<response>\n' ' <message_text>%s</message_text>\n' '</response>\n' % django.utils.html.escape(' ## '.join(responses)))
def delete_note(id): note = Note.objects(id=id).first() if not note: raise NotFound("Note not found") note.delete() return jsonify({"message": "Deleted note with success"})
def save_note(note): # add note to hash with note ID as key rds.hmset(note.uid, Note.dict_repr(note)) # add note ID to index list rds.lpush('notes', note.uid)