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
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
