def get(self): if self.config.search_auth_key_required and not ( self.auth and self.auth.search_permission): return self.error(403, 'Missing or invalid authorization key\n') pfif_version = pfif.PFIF_VERSIONS.get(self.params.version or '1.2') # Retrieve parameters and do some sanity checks on them. query_string = self.request.get("q") subdomain = self.request.get("subdomain") max_results = min(self.params.max_results or 100, HARD_MAX_RESULTS) if not query_string: return self.error(400, 'Missing q parameter') if not subdomain: return self.error(400, 'Missing subdomain parameter') # Perform the search. results = indexing.search(Person.all_in_subdomain(subdomain), TextQuery(query_string), max_results) records = [pfif_version.person_to_dict(result) for result in results] utils.optionally_filter_sensitive_fields(records, self.auth) # Define the function to retrieve notes for a person. def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.subdomain, person['person_record_id']) records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) return records self.response.headers['Content-Type'] = 'application/xml' pfif_version.write_file(self.response.out, records, get_notes_for_person)
def get(self): if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.info(403, message='Missing or invalid authorization key', style='plain') return pfif_version = self.params.version # Note that self.request.get can handle multiple IDs at once; we # can consider adding support for multiple records later. record_id = self.request.get('id') if not record_id: self.info(400, message='Missing id parameter', style='plain') return person = model.Person.get(self.repo, record_id, filter_expired=False) if not person: self.info(400, message='No person record with ID %s' % record_id, style='plain') return notes = model.Note.get_by_person_record_id(self.repo, record_id) notes = [note for note in notes if not note.hidden] self.response.headers['Content-Type'] = 'application/xml' records = [pfif_version.person_to_dict(person, person.is_expired)] note_records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) utils.optionally_filter_sensitive_fields(note_records, self.auth) pfif_version.write_file(self.response.out, records, lambda p: note_records) utils.log_api_action(self, ApiActionLog.READ, len(records), len(notes))
def get(self): if self.config.search_auth_key_required and not ( self.auth and self.auth.search_permission): self.info(403, message='Missing or invalid authorization key', style='plain') return pfif_version = self.params.version # Retrieve parameters and do some sanity checks on them. record_id = self.request.get('id') query_string = self.request.get('q') max_results = min(self.params.max_results or 100, HARD_MAX_RESULTS) results = [] if record_id: # Search by record ID (always returns just 1 result or nothing). person = model.Person.get(self.repo, record_id) if person: results = [person] elif query_string: # Search by query words. if self.config.external_search_backends: query = TextQuery(query_string) results = external_search.search( self.repo, query, max_results, self.config.external_search_backends) # External search backends are not always complete. Fall back to # the original search when they fail or return no results. if not results: if config.get('enable_fulltext_search'): results = full_text_search.search(self.repo, query_string, max_results) else: results = indexing.search(self.repo, TextQuery(query_string), max_results) else: self.info(400, message='Neither id nor q parameter specified', style='plain') records = [pfif_version.person_to_dict(result) for result in results] utils.optionally_filter_sensitive_fields(records, self.auth) # Define the function to retrieve notes for a person. def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.repo, person['person_record_id']) notes = [note for note in notes if not note.hidden] records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) return records self.response.headers[ 'Content-Type'] = 'application/xml; charset=utf-8' pfif_version.write_file(self.response.out, records, get_notes_for_person) utils.log_api_action(self, ApiActionLog.SEARCH, len(records))
def get(self): if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.response.set_status(403) self.write('Missing or invalid authorization key\n') return pfif_version = get_pfif_version(self.params) atom_version = atom.ATOM_PFIF_VERSIONS.get(pfif_version.version) max_results = min(self.params.max_results or 10, HARD_MAX_RESULTS) skip = min(self.params.skip or 0, MAX_SKIP) query = model.Note.all_in_subdomain(self.subdomain) if self.params.min_entry_date: # Scan forward. query = query.order('entry_date') query = query.filter('entry_date >=', self.params.min_entry_date) else: # Show recent entries, scanning backward. query = query.order('-entry_date') if self.params.person_record_id: # Show notes for a specific person. query = query.filter('person_record_id =', self.params.person_record_id) notes = query.fetch(max_results, skip) updated = get_latest_entry_date(notes) self.response.headers['Content-Type'] = 'application/xml' records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) atom_version.write_note_feed( self.response.out, records, self.request.url, self.env.netloc, '', updated)
def get(self): if self.config.read_auth_key_required and not (self.auth and self.auth.read_permission): self.response.set_status(403) self.write("Missing or invalid authorization key\n") return pfif_version = pfif.PFIF_VERSIONS.get(self.params.version or pfif.PFIF_DEFAULT_VERSION) # Note that self.request.get can handle multiple IDs at once; we # can consider adding support for multiple records later. record_id = self.request.get("id") if not record_id: return self.error(400, "Missing id parameter") person = model.Person.get(self.subdomain, record_id, filter_expired=False) if not person: return self.error(404, "No person record with ID %s" % record_id) notes = model.Note.get_by_person_record_id(self.subdomain, record_id) self.response.headers["Content-Type"] = "application/xml" records = [pfif_version.person_to_dict(person, person.is_expired)] note_records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) utils.optionally_filter_sensitive_fields(note_records, self.auth) pfif_version.write_file(self.response.out, records, lambda p: note_records)
def get(self): if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.response.set_status(403) self.write('Missing or invalid authorization key\n') return pfif_version = get_pfif_version(self.params) atom_version = atom.ATOM_PFIF_VERSIONS.get(pfif_version.version) max_results = min(self.params.max_results or 10, HARD_MAX_RESULTS) skip = min(self.params.skip or 0, MAX_SKIP) query = model.Note.all_in_subdomain(self.subdomain) if self.params.min_entry_date: # Scan forward. query = query.order('entry_date') query = query.filter('entry_date >=', self.params.min_entry_date) else: # Show recent entries, scanning backward. query = query.order('-entry_date') if self.params.person_record_id: # Show notes for a specific person. query = query.filter('person_record_id =', self.params.person_record_id) notes = query.fetch(max_results, skip) updated = get_latest_entry_date(notes) self.response.headers['Content-Type'] = 'application/xml' records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) atom_version.write_note_feed(self.response.out, records, self.request.url, self.env.netloc, '', updated)
def get(self): if self.config.search_auth_key_required and not (self.auth and self.auth.search_permission): return self.error(403, "Missing or invalid authorization key\n") pfif_version = pfif.PFIF_VERSIONS.get(self.params.version or "1.2") # Retrieve parameters and do some sanity checks on them. query_string = self.request.get("q") subdomain = self.request.get("subdomain") max_results = min(self.params.max_results or 100, HARD_MAX_RESULTS) if not query_string: return self.error(400, "Missing q parameter") if not subdomain: return self.error(400, "Missing subdomain parameter") # Perform the search. results = indexing.search(Person.all_in_subdomain(subdomain), TextQuery(query_string), max_results) records = [pfif_version.person_to_dict(result) for result in results] utils.optionally_filter_sensitive_fields(records, self.auth) # Define the function to retrieve notes for a person. def get_notes_for_person(person): notes = model.Note.get_by_person_record_id(self.subdomain, person["person_record_id"]) records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) return records self.response.headers["Content-Type"] = "application/xml" pfif_version.write_file(self.response.out, records, get_notes_for_person)
def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.repo, person['person_record_id']) notes = [note for note in notes if not note.hidden] records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) return records
def get(self): if self.config.read_auth_key_required and not (self.auth and self.auth.read_permission): self.info(403, message="Missing or invalid authorization key", style="plain") return pfif_version = self.params.version # Note that self.request.get can handle multiple IDs at once; we # can consider adding support for multiple records later. record_id = self.request.get("id") if not record_id: self.info(400, message="Missing id parameter", style="plain") return person = model.Person.get(self.repo, record_id, filter_expired=False) if not person: self.info(400, message="No person record with ID %s" % record_id, style="plain") return notes = model.Note.get_by_person_record_id(self.repo, record_id) notes = [note for note in notes if not note.hidden] self.response.headers["Content-Type"] = "application/xml" records = [pfif_version.person_to_dict(person, person.is_expired)] note_records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) utils.optionally_filter_sensitive_fields(note_records, self.auth) pfif_version.write_file(self.response.out, records, lambda p: note_records) utils.log_api_action(self, ApiActionLog.READ, len(records), len(notes))
def get(self): if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.response.set_status(403) self.write('Missing or invalid authorization key\n') return max_results = min(self.params.max_results or 10, HARD_MAX_RESULTS) skip = min(self.params.skip or 0, MAX_SKIP) if self.params.omit_notes: # Return only the person records. get_notes_for_person = lambda person: [] else: def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.subdomain, person['person_record_id']) records = map(pfif.PFIF_1_2.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) return records query = model.Person.all_in_subdomain(self.subdomain) if self.params.min_entry_date: # Scan forward. query = query.order('entry_date') query = query.filter('entry_date >=', self.params.min_entry_date) else: # Show recent entries, scanning backward. query = query.order('-entry_date') persons = query.fetch(max_results, skip) updated = get_latest_entry_date(persons) self.response.headers['Content-Type'] = 'application/xml' records = map(pfif.PFIF_1_2.person_to_dict, persons) utils.optionally_filter_sensitive_fields(records, self.auth) atom.ATOM_PFIF_1_2.write_person_feed( self.response.out, records, get_notes_for_person, self.request.url, self.env.netloc, '', updated)
def get(self): if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.response.set_status(403) self.write('Missing or invalid authorization key\n') return pfif_version = pfif.PFIF_VERSIONS.get(self.params.version or pfif.PFIF_DEFAULT_VERSION) # Note that self.request.get can handle multiple IDs at once; we # can consider adding support for multiple records later. record_id = self.request.get('id') if not record_id: return self.error(400, 'Missing id parameter') person = model.Person.get(self.subdomain, record_id, filter_expired=False) if not person: return self.error(404, 'No person record with ID %s' % record_id) notes = model.Note.get_by_person_record_id(self.subdomain, record_id) self.response.headers['Content-Type'] = 'application/xml' records = [pfif_version.person_to_dict(person, person.is_expired)] note_records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) utils.optionally_filter_sensitive_fields(note_records, self.auth) pfif_version.write_file(self.response.out, records, lambda p: note_records)
def get(self): if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.response.set_status(403) self.write('Missing or invalid authorization key\n') return pfif_version = self.params.version # Note that self.request.get can handle multiple IDs at once; we # can consider adding support for multiple records later. record_id = self.request.get('id') if not record_id: return self.error(400, 'Missing id parameter') person = model.Person.get( self.repo, record_id, filter_expired=False) if not person: return self.error(404, 'No person record with ID %s' % record_id) notes = model.Note.get_by_person_record_id(self.repo, record_id) notes = [note for note in notes if not note.hidden] self.response.headers['Content-Type'] = 'application/xml' records = [pfif_version.person_to_dict(person, person.is_expired)] note_records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) utils.optionally_filter_sensitive_fields(note_records, self.auth) pfif_version.write_file( self.response.out, records, lambda p: note_records) utils.log_api_action( self, ApiActionLog.READ, len(records), len(notes))
def get(self): if self.config.search_auth_key_required and not ( self.auth and self.auth.search_permission): self.info( 403, message='Missing or invalid authorization key', style='plain') return pfif_version = self.params.version # Retrieve parameters and do some sanity checks on them. record_id = self.request.get('id') query_string = self.request.get('q') max_results = min(self.params.max_results or 100, HARD_MAX_RESULTS) results = [] if record_id: # Search by record ID (always returns just 1 result or nothing). person = model.Person.get(self.repo, record_id) if person: results = [person] elif query_string: # Search by query words. if self.config.external_search_backends: query = TextQuery(query_string) results = external_search.search(self.repo, query, max_results, self.config.external_search_backends) # External search backends are not always complete. Fall back to # the original search when they fail or return no results. if not results: if config.get('enable_fulltext_search'): results = full_text_search.search( self.repo, query_string, max_results) else: results = indexing.search( self.repo, TextQuery(query_string), max_results) else: self.info( 400, message='Neither id nor q parameter specified', style='plain') records = [pfif_version.person_to_dict(result) for result in results] utils.optionally_filter_sensitive_fields(records, self.auth) # Define the function to retrieve notes for a person. def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.repo, person['person_record_id']) notes = [note for note in notes if not note.hidden] records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) return records self.response.headers['Content-Type'] = 'application/xml; charset=utf-8' pfif_version.write_file( self.response.out, records, get_notes_for_person) utils.log_api_action(self, ApiActionLog.SEARCH, len(records))
def get(self): if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.response.set_status(403) self.write('Missing or invalid authorization key\n') return pfif_version = self.params.version atom_version = atom.ATOM_PFIF_VERSIONS.get(pfif_version.version) max_results = min(self.params.max_results or 10, HARD_MAX_RESULTS) skip = self.params.skip or 0 # We use a member because a var can't be modified inside the closure. self.num_notes = 0 def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.repo, person['person_record_id']) # Show hidden notes as blank in the Person feed (melwitt) # https://web.archive.org/web/20111228161607/http://code.google.com/p/googlepersonfinder/issues/detail?id=58 make_hidden_notes_blank(notes) records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) self.num_notes += len(notes) return records if self.params.omit_notes: # Return only the person records. get_notes_for_person = lambda person: [] query = model.Person.all_in_repo(self.repo, filter_expired=False) if self.params.min_entry_date: # Scan forward. query = query.order('entry_date') query = query.filter('entry_date >=', self.params.min_entry_date) else: # Show recent entries, scanning backward. query = query.order('-entry_date') persons = query.fetch(max_results, offset=skip) updated = get_latest_entry_date(persons) self.response.headers[ 'Content-Type'] = 'application/xml; charset=utf-8' records = [ pfif_version.person_to_dict(person, person.is_expired) for person in persons ] utils.optionally_filter_sensitive_fields(records, self.auth) atom_version.write_person_feed(self.response.out, records, get_notes_for_person, self.request.url, self.env.netloc, PERSON_SUBTITLE_BASE + self.env.netloc, updated) utils.log_api_action(self, model.ApiActionLog.READ, len(records), self.num_notes)
def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.repo, person['person_record_id']) # Show hidden notes as blank in the Person feed (melwitt) # http://code.google.com/p/googlepersonfinder/issues/detail?id=58 make_hidden_notes_blank(notes) records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) self.num_notes += len(notes) return records
def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.repo, person['person_record_id']) # Show hidden notes as blank in the Person feed (melwitt) # https://web.archive.org/web/20111228161607/http://code.google.com/p/googlepersonfinder/issues/detail?id=58 make_hidden_notes_blank(notes) records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) self.num_notes += len(notes) return records
def get(self): if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.response.set_status(403) self.write('Missing or invalid authorization key\n') return pfif_version = self.params.version atom_version = atom.ATOM_PFIF_VERSIONS.get(pfif_version.version) max_results = min(self.params.max_results or 10, HARD_MAX_RESULTS) skip = self.params.skip or 0 # We use a member because a var can't be modified inside the closure. self.num_notes = 0 def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.repo, person['person_record_id']) # Show hidden notes as blank in the Person feed (melwitt) # http://code.google.com/p/googlepersonfinder/issues/detail?id=58 make_hidden_notes_blank(notes) records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) self.num_notes += len(notes) return records if self.params.omit_notes: # Return only the person records. get_notes_for_person = lambda person: [] query = model.Person.all_in_repo(self.repo, filter_expired=False) if self.params.min_entry_date: # Scan forward. query = query.order('entry_date') query = query.filter('entry_date >=', self.params.min_entry_date) else: # Show recent entries, scanning backward. query = query.order('-entry_date') persons = query.fetch(max_results, offset=skip) updated = get_latest_entry_date(persons) self.response.headers['Content-Type'] = 'application/xml' records = [pfif_version.person_to_dict(person, person.is_expired) for person in persons] utils.optionally_filter_sensitive_fields(records, self.auth) atom_version.write_person_feed( self.response.out, records, get_notes_for_person, self.request.url, self.env.netloc, PERSON_SUBTITLE_BASE + self.env.netloc, updated) utils.log_api_action(self, model.ApiActionLog.READ, len(records), self.num_notes)
def get(self): # SSL and auth key is not required if a feed for a specific person # is requested. Note that the feed icon on the person record page # links to HTTP version without auth key. if not self.params.person_record_id: # Check for SSL (unless running on localhost for development). if self.env.scheme != 'https' and self.env.domain != 'localhost': self.response.set_status(403) self.write('HTTPS is required.\n') return if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.response.set_status(403) self.write('Missing or invalid authorization key\n') return pfif_version = self.params.version atom_version = atom.ATOM_PFIF_VERSIONS.get(pfif_version.version) max_results = min(self.params.max_results or 10, HARD_MAX_RESULTS) skip = self.params.skip or 0 query = model.Note.all_in_repo(self.repo) if self.params.min_entry_date: # Scan forward. query = query.order('entry_date') query = query.filter('entry_date >=', self.params.min_entry_date) else: # Show recent entries, scanning backward. query = query.order('-entry_date') if self.params.person_record_id: # Show notes for a specific person. query = query.filter('person_record_id =', self.params.person_record_id) notes = query.fetch(max_results, offset=skip) updated = get_latest_entry_date(notes) # Show hidden notes as blank in the Note feed (melwitt) # https://web.archive.org/web/20111228161607/http://code.google.com/p/googlepersonfinder/issues/detail?id=58 make_hidden_notes_blank(notes) self.response.headers[ 'Content-Type'] = 'application/xml; charset=utf-8' records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) atom_version.write_note_feed(self.response.out, records, self.request.url, self.env.netloc, NOTE_SUBTITLE_BASE + self.env.netloc, updated) utils.log_api_action(self, model.ApiActionLog.READ, 0, len(records))
def get(self): # SSL and auth key is not required if a feed for a specific person # is requested. Note that the feed icon on the person record page # links to HTTP version without auth key. if not self.params.person_record_id: # Check for SSL (unless running on localhost for development). if self.env.scheme != 'https' and self.env.domain != 'localhost': self.response.set_status(403) self.write('HTTPS is required.\n') return if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.response.set_status(403) self.write('Missing or invalid authorization key\n') return pfif_version = self.params.version atom_version = atom.ATOM_PFIF_VERSIONS.get(pfif_version.version) max_results = min(self.params.max_results or 10, HARD_MAX_RESULTS) skip = self.params.skip or 0 query = model.Note.all_in_repo(self.repo) if self.params.min_entry_date: # Scan forward. query = query.order('entry_date') query = query.filter('entry_date >=', self.params.min_entry_date) else: # Show recent entries, scanning backward. query = query.order('-entry_date') if self.params.person_record_id: # Show notes for a specific person. query = query.filter('person_record_id =', self.params.person_record_id) notes = query.fetch(max_results, offset=skip) updated = get_latest_entry_date(notes) # Show hidden notes as blank in the Note feed (melwitt) # http://code.google.com/p/googlepersonfinder/issues/detail?id=58 make_hidden_notes_blank(notes) self.response.headers['Content-Type'] = 'application/xml' records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) atom_version.write_note_feed( self.response.out, records, self.request.url, self.env.netloc, NOTE_SUBTITLE_BASE + self.env.netloc, updated) utils.log_api_action(self, model.ApiActionLog.READ, 0, len(records))
def get(self): if self.config.read_auth_key_required and not ( self.auth and self.auth.read_permission): self.response.set_status(403) self.write('Missing or invalid authorization key\n') return pfif_version = get_pfif_version(self.params) atom_version = atom.ATOM_PFIF_VERSIONS.get(pfif_version.version) max_results = min(self.params.max_results or 10, HARD_MAX_RESULTS) skip = min(self.params.skip or 0, MAX_SKIP) if self.params.omit_notes: # Return only the person records. get_notes_for_person = lambda person: [] else: def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.subdomain, person['person_record_id']) records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) return records query = model.Person.all_in_subdomain(self.subdomain, filter_expired=False) if self.params.min_entry_date: # Scan forward. query = query.order('entry_date') query = query.filter('entry_date >=', self.params.min_entry_date) else: # Show recent entries, scanning backward. query = query.order('-entry_date') persons = query.fetch(max_results, skip) updated = get_latest_entry_date(persons) self.response.headers['Content-Type'] = 'application/xml' records = [ pfif_version.person_to_dict(person, person.is_expired) for person in persons ] utils.optionally_filter_sensitive_fields(records, self.auth) atom_version.write_person_feed(self.response.out, records, get_notes_for_person, self.request.url, self.env.netloc, '', updated)
def get_notes_for_person(person): notes = model.Note.get_by_person_record_id( self.subdomain, person['person_record_id']) records = map(pfif_version.note_to_dict, notes) utils.optionally_filter_sensitive_fields(records, self.auth) return records