def post(self):
title_raw = self.request.POST.get('title_url')
title = Plaque.tokenize_title(title_raw)
n_matches = Plaque.num_same_title_urls_published(
title, get_plaqueset_key())
response_text = title if n_matches > 0 else ""
self.response.write(response_text)
def get(self):
find_orphans = self.request.get('find_orphans')
num_comments = Comment.query().count()
query = Plaque.query()
num_plaques = query.count()
num_pending = query.filter(Plaque.approved == False).count()
num_images = 0
images = gcs.listbucket(GCS_BUCKET)
for image in images:
num_images += 1
orphan_pics = set()
pics_count = defaultdict(int)
pics = set()
if find_orphans == 'true':
# Record which pics are linked to a plaque:
plaques = Plaque.query().fetch()
for plaque in plaques:
pics.add(plaque.pic)
pics_count[plaque.pic] += 1
# Find pics that aren't:
for pic in images:
if pic not in pics:
orphan_pics.add(pic)
else:
orphan_pics.add("didn't check for orphans")
msg = "Count: %s comments, %s plaques (%s pending), %s images, orphans: %s<hr>%s" % (
num_comments, num_plaques, num_pending, num_images, orphan_pics, pics_count)
self.response.write(msg)
def get(self, tag, view_all=False):
"""
View plaques with a given tag on a grid.
"""
memcache_name = 'plaques_tag_%s' % tag
page_text = memcache.get(memcache_name)
if page_text is None:
query = Plaque.query()
if not view_all:
query = query.filter(Plaque.approved == True)
# TODO: NDB cursor pagination?
plaques = query.filter(
Plaque.tags == tag).order(-Plaque.created_on).fetch(
limit=DEF_NUM_PER_PAGE)
template = JINJA_ENVIRONMENT.get_template('all.html')
template_values = get_template_values(plaques=plaques)
page_text = template.render(template_values)
memcache_status = memcache.set(memcache_name, page_text)
if not memcache_status:
logging.debug("ViewTag memcache.set for %s failed" %
memcache_name)
else:
logging.debug("ViewTag memcache.get worked for %s" % memcache_name)
self.response.write(page_text)
def get_featured():
featured = FeaturedPlaque.query().order(-Plaque.created_on).get()
if featured is not None:
plaque = Plaque.query().filter(Plaque.key == featured.plaque).get()
else:
plaque = None
return plaque
def get(self):
plaques = Plaque.query().fetch()
for plaque in plaques:
plaque.set_title_url()
plaque.put()
memcache.flush_all()
self.redirect('/')
def get(self, tag, view_all=False):
"""
View plaque with a given tag on a grid.
"""
memcache_name = 'plaque_json_%s' % tag
page_text = memcache.get(memcache_name)
if page_text is None:
query = Plaque.query()
if not view_all:
query = query.filter(Plaque.approved == True)
# TODO: NDB cursor pagination?
plaques = query.filter(Plaque.tags == tag
).order(-Plaque.created_on
).fetch(limit=DEF_NUM_PER_PAGE)
map_markers_str = get_map_markers_str(plaques)
template = JINJA_ENVIRONMENT.get_template('all.html')
template_values = get_default_template_values(
plaques=plaques,
map_markers_str=map_markers_str,
)
page_text = template.render(template_values)
memcache_status = memcache.set(memcache_name, page_text)
if not memcache_status:
logging.debug("ViewTag memcache.set for %s failed" %
memcache_name)
else:
logging.debug("ViewTag memcache.get worked for %s" %
memcache_name)
self.response.write(page_text)
def _get_page_from_key(self, plaque_key=None):
"""
Put the single plaque into a list for rendering so that the common map
functionality can be used unchanged. Attempt to serve a valid plaque,
but if the inputs are completely messed up, serve the oldest plaque.
"""
# If it's memecached, use that:
is_admin = users.is_current_user_admin()
memcache_name = 'plaque_%s_%s' % (plaque_key, is_admin)
page_text = memcache.get(memcache_name)
if page_text is not None:
return page_text
# If page is not memcached, get the plaque from the db:
plaque = self._get_plaque_from_key(plaque_key)
# If that didn't find anything, serve the default couldn't-find-it
# plaque (currently hacked in as the earliest plaque):
if plaque is None:
earliest_plaque = Plaque.query(Plaque.approved == True).order(
Plaque.created_on).get()
self.redirect(earliest_plaque.title_page_url)
return
template_values = get_template_values(plaques=[plaque])
template = JINJA_ENVIRONMENT.get_template('one.html')
page_text = template.render(template_values)
memcache_status = memcache.set(memcache_name, page_text)
if not memcache_status:
logging.debug("memcache.set for _get_page_from_key failed for %s" %
memcache_name)
return page_text
def get(self):
plaques = Plaque.query().fetch()
for plaque in plaques:
plaque.set_title_url()
plaque.put()
memcache.flush_all()
self.redirect('/')
def get(self, num=DEF_NUM_PENDING):
try:
num = int(num)
except:
pass
plaques = Plaque.pending_list(num=num, desc=False)
self.write_pending(plaques)
def _get_template_values(self, per_page, cursor_urlsafe, is_random, is_featured):
if is_random:
plaques = []
cursor_urlsafe = None
more = False
for i in range(per_page):
plaques.append(get_random_plaque())
else:
plaques, next_cursor, more = Plaque.page_plaques(
per_page, start_cursor_urlsafe=cursor_urlsafe)
if next_cursor is None:
cursor_urlsafe = ''
else:
cursor_urlsafe = next_cursor.urlsafe()
#num_plaques = Plaque.query().count()
#num_pages = int(math.ceil((num_plaques / per_page)))
template_values = get_default_template_values(
plaques=plaques,
#num_pages=num_pages,
next_cursor_urlsafe=cursor_urlsafe,
more=more,
)
if is_random:
template_values['map_markers_str'] = get_map_markers_str(plaques)
if is_featured:
featured = get_featured()
template_values['featured_plaque'] = featured
return template_values
def get(self, num_entries=10):
plaques = Plaque.query().filter(
Plaque.approved == True).order(-Plaque.created_on).fetch(
limit=num_entries)
template = JINJA_ENVIRONMENT.get_template('feed.xml')
template_values = {'plaques': plaques}
self.response.write(template.render(template_values))
def get(self):
plaques = Plaque.query().filter(
Plaque.updated_on == None).order(-Plaque.created_on).fetch()
for plaque in plaques:
plaque.updated_on = plaque.created_on
plaque.put()
self.response.write([p.title for p in plaques])
def get_featured():
featured = FeaturedPlaque.query().order(-Plaque.created_on).get()
if featured is not None:
plaque = Plaque.query().filter(Plaque.key == featured.plaque).get()
else:
plaque = None
return plaque
def _get_template_values(self, per_page, cursor_urlsafe, is_random,
is_featured):
if is_random:
plaques = []
cursor_urlsafe = None
more = False
for i in range(per_page):
plaques.append(get_random_plaque())
else:
plaques, next_cursor, more = Plaque.fetch_page(
per_page, start_cursor=cursor_urlsafe, urlsafe=True)
if next_cursor is None:
cursor_urlsafe = ''
else:
cursor_urlsafe = next_cursor.urlsafe()
template_values = get_template_values(
plaques=plaques, next_cursor_urlsafe=cursor_urlsafe, more=more)
if is_featured:
featured = get_featured()
template_values['featured_plaque'] = featured
fake = FakePlaqueForRootUrlPreviews()
template_values['fake_plaque_for_root_url_previews'] = fake
return template_values
def get_default_template_values(**kwargs):
memcache_name = 'default_template_values_%s' % users.is_current_user_admin()
template_values = memcache.get(memcache_name)
if template_values is None:
num_pending = Plaque.num_pending(num=DEF_NUM_PENDING)
footer_items = get_footer_items()
loginout_output = loginout()
template_values = {
'num_pending': num_pending,
'footer_items': footer_items,
'loginout': loginout_output,
'icon_size': DEF_MAP_ICON_SIZE_PIX,
}
memcache_status = memcache.set(memcache_name, template_values)
if not memcache_status:
logging.debug(
"memcaching.set to %s for default_template_values failed" %
memcache_name)
else:
logging.debug(
"memcache.get from %s worked for default_template_values" %
memcache_name)
for k, v in kwargs.items():
template_values[k] = v
return template_values
def get(self, num_entries=10):
plaques = Plaque.query(
).filter(Plaque.approved == True
).order(-Plaque.created_on
).fetch(limit=num_entries)
template = JINJA_ENVIRONMENT.get_template('feed.xml')
template_values = {'plaques': plaques}
self.response.write(template.render(template_values))
def get(self):
#raise NotImplementedError("Turned off")
plaques = Plaque.pending_list(num=500)
for plaque in plaques:
plaque.approved = True
plaque.put()
memcache.flush_all()
self.redirect('/')
def get(self):
plaques = Plaque.query(
).filter(Plaque.updated_on == None
).order(-Plaque.created_on
).fetch()
for plaque in plaques:
plaque.updated_on = plaque.created_on
plaque.put()
self.response.write([p.title for p in plaques])
def get_random_time():
"""
Get a random time during the operation of the site.
"""
memcache_names = ['first', 'last']
memcache_out = memcache.get_multi(memcache_names)
memcache_worked = len(memcache_out.keys()) == len(memcache_names)
if memcache_worked:
first = memcache_out[memcache_names[0]]
last = memcache_out[memcache_names[1]]
else:
first_plaque = Plaque.query().filter(Plaque.approved == True).order(
Plaque.created_on).get()
if first_plaque:
first = first_plaque.created_on
else:
first = None
last_plaque = Plaque.query().filter(
Plaque.approved == True).order(-Plaque.created_on).get()
if last_plaque:
last = last_plaque.created_on
else:
last = None
memcache_status = memcache.set_multi({
memcache_names[0]: first,
memcache_names[1]: last
})
if memcache_status:
logging.debug("""memcache.set in Handlers.get_random_time() failed:
%s were not set""" % memcache_status)
if first is None or last is None:
random_time = None
else:
diff = last - first
diff_seconds = int(diff.total_seconds())
rand_seconds = random.randint(0, diff_seconds)
random_delta = datetime.timedelta(seconds=rand_seconds)
random_time = first + random_delta
return random_time
def _json_for_update(self, updated_on, summary=True):
logging.info("Updated_on is %s in _json_for_update" % updated_on)
plaques = Plaque.query().filter(Plaque.approved == True).filter(
Plaque.created_on > updated_on).order(-Plaque.created_on).fetch()
logging.info("_json_for_update got %s plaques" % len(plaques))
for i, plaque in enumerate(plaques):
logging.info("_json_for_update plaque %s date: %s" %
(i, plaque.updated_on))
json_output = self._plaques_to_json(plaques, summary)
return json_output
def get(self):
plaques = Plaque.pending_list(1)
if plaques:
plaque = plaques[0]
logging.info("redirecting to {}".format(plaque.title_page_url))
self.redirect(plaque.title_page_url)
return
else:
page_text = self._get_page_from_key(plaque_key=None)
self.response.write(page_text)
def get(self, num=DEF_NUM_PENDING):
try:
num = int(num)
except:
pass
num_to_select_from = 500
plaques = Plaque.pending_list(num_to_select_from)
return_plaques = random.sample(plaques, num)
self.write_pending(return_plaques)
def _json_for_update(self, updated_on, summary=True):
logging.info("Updated_on is %s in _json_for_update" % updated_on)
plaques = Plaque.query(
).filter(Plaque.approved == True
).filter(Plaque.created_on > updated_on
).order(-Plaque.created_on
).fetch()
logging.info("_json_for_update got %s plaques" % len(plaques))
for i, plaque in enumerate(plaques):
logging.info("_json_for_update plaque %s date: %s" % (i, plaque.updated_on))
json_output = self._plaques_to_json(plaques, summary)
return json_output
def get_random_time():
"""
Get a random time during the operation of the site.
"""
memcache_names = ['first', 'last']
memcache_out = memcache.get_multi(memcache_names)
memcache_worked = len(memcache_out.keys()) == len(memcache_names)
if memcache_worked:
first = memcache_out[memcache_names[0]]
last = memcache_out[memcache_names[1]]
else:
first_plaque = Plaque.query().filter(Plaque.approved == True).order(Plaque.created_on).get()
if first_plaque:
first = first_plaque.created_on
else:
first = None
last_plaque = Plaque.query().filter(Plaque.approved == True).order(-Plaque.created_on).get()
if last_plaque:
last = last_plaque.created_on
else:
last = None
memcache_status = memcache.set_multi({
memcache_names[0]: first,
memcache_names[1]: last
})
if memcache_status:
logging.debug("""memcache.set in Handlers.get_random_time() failed:
%s were not set""" % memcache_status)
if first is None or last is None:
random_time = None
else:
diff = last - first
diff_seconds = int(diff.total_seconds())
rand_seconds = random.randint(0, diff_seconds)
random_offset = datetime.timedelta(seconds=rand_seconds)
random_time = first + random_offset
return random_time
def get(self):
verbose = self.request.get('verbose')
query = Plaque.query()
num_plaques = query.count()
num_pending = query.filter(Plaque.approved == False).count()
if verbose:
tmpl = "<ul> <li>{} published</li> <li>{} pending</li> </ul>"
else:
tmpl = "{} published, {} pending\n"
msg = tmpl.format(num_plaques - num_pending, num_pending)
self.response.write(msg)
def _json_for_all(self, summary=True):
plaques_all = []
num = 1000
more = True
cursor = None
while more:
plaques, cursor, more = Plaque.fetch_page(num=num,
start_cursor=cursor,
urlsafe=False)
plaques_all.extend(plaques)
logging.info("tot: %s, current: %s, cursor: %s, more?: %s" %
(len(plaques_all), len(plaques_all), cursor, more))
json_output = self._plaques_to_json(plaques_all, summary)
return json_output
def get(self):
plaques = Plaque.query().fetch()
plaque_search_index = search.Index(PLAQUE_SEARCH_INDEX_NAME)
igood = 0
ibad = 0
for plaque in plaques:
try:
plaque_search_index.put(plaque.to_search_document())
igood += 1
except search.Error as err:
ibad += 1
logging.error(err)
logging.debug('in process: wrote %s good docs, %s failed' % (
igood, ibad))
self.response.write('wrote %s good docs, %s failed' % (igood, ibad))
def get(self):
plaques = Plaque.query().fetch()
plaque_search_index = search.Index(PLAQUE_SEARCH_INDEX_NAME)
igood = 0
ibad = 0
for plaque in plaques:
try:
plaque_search_index.put(plaque.to_search_document())
igood += 1
except search.Error as err:
ibad += 1
logging.error(err)
logging.debug('in process: wrote %s good docs, %s failed' %
(igood, ibad))
self.response.write('wrote %s good docs, %s failed' % (igood, ibad))
def get(self, lat=None, lng=None, zoom=None):
template_values = get_template_values(bigmap=True)
query = Plaque.query()
num_plaques = query.filter(Plaque.approved == True).count()
template_values['counts'] = num_plaques
logging.debug(template_values)
if lat is not None and lng is not None:
template_values['bigmap_center'] = True
template_values['bigmap_lat'] = lat
template_values['bigmap_lng'] = lng
if zoom is not None:
template_values['bigmap_zoom'] = zoom
template = JINJA_ENVIRONMENT.get_template(self.template_file)
template_text = template.render(template_values)
self.response.write(template_text)
def _json_for_all(self, summary=True):
# TODO: this should not hardcode a 20k plaque limit.
# TODO: NDB cursor pagination for this
block_size = 1000
num_blocks = 20
max_num_plaques = num_blocks * block_size
plaques_all = []
for ik in range(0, max_num_plaques, block_size):
plaques = Plaque.query(
).filter(Plaque.approved == True
).order(-Plaque.created_on
).fetch(offset=ik, limit=block_size)
# Now add it to the total list:
plaques_all.extend(plaques)
json_output = self._plaques_to_json(plaques_all, summary)
return json_output
def get(self, num=DEF_NUM_PENDING):
try:
num = int(num)
except:
pass
plaques = Plaque.pending_list(num)
user = users.get_current_user()
name = "anon" if user is None else user.nickname()
logging.info("User %s is viewing pending plaques" % name)
template = JINJA_ENVIRONMENT.get_template('all.html')
map_markers_str = get_map_markers_str(plaques)
template_values = get_default_template_values(
map_markers_str=map_markers_str,
plaques=plaques,
)
template_text = template.render(template_values)
self.response.write(template_text)
def _get_plaque_from_key(self, plaque_key=None):
# Get plaque from db from db:
plaque = None
logging.info("plaque_key=%s" % plaque_key)
if plaque_key is not None:
# Get by title, allowing only admins to see unapproved ones:
logging.debug("Using plaque.title_url: '%s'" % plaque_key)
query = Plaque.query().filter(Plaque.title_url == plaque_key)
if not users.is_current_user_admin():
query = query.filter(Plaque.approved == True)
logging.debug("query is %s " % query)
plaque = query.get()
if plaque is None:
try:
plaque = ndb.Key(urlsafe=plaque_key).get()
except:
pass
return plaque
def get(self):
#raise NotImplementedError("Turned off")
if not users.is_current_user_admin():
return "admin only, please log in"
plaques = Plaque.pending_list(num=67)
user = users.get_current_user()
name = "anon" if user is None else user.nickname()
msg = "%s ran ApproveAllPending on %s plaques" % (name, len(plaques))
email_admin(msg, msg)
logging.info("Approving %s plaques in ApproveAllPending" %
len(plaques))
for plaque in plaques:
plaque.approved = True
plaque.put()
memcache.flush_all()
self.redirect('/')
def get(self):
plaque_search_index = search.Index(PLAQUE_SEARCH_INDEX_NAME)
ideleted = 0
# Delete all the search documents
while True:
# Get a list of documents populating only the doc_id field and
# extract the ids.
document_ids = [
document.doc_id
for document in plaque_search_index.get_range(ids_only=True)
]
ideleted += len(document_ids)
if not document_ids:
break
# Delete the documents for the given ids from the Index.
plaque_search_index.delete(document_ids)
logging.debug('deleted %s search index docs' % ideleted)
# Write all new search docs and put them in the index
plaques = Plaque.query().fetch()
docs = []
igood = 0
ibad = 0
for plaque in plaques:
try:
docs.append(plaque.to_search_document())
igood += 1
except search.Error as err:
ibad += 1
logging.error(err)
#if ip % 100 == 0:
#logging.debug('in process: wrote %s good docs, %s failed' % (
#igood, ibad))
iput = 0
for i in range(0, len(docs), 100):
iput += 100
plaque_search_index.put(docs[i:i + 100])
self.response.write(
'deleted %s docs, created %s, failed to create %s, put %s' %
(ideleted, igood, ibad, iput))
def get_random_plaque_key():
"""
Get a random plaque key. Limit to total number of runs to 100 to prevent
infinite loop if there are no plaques.
"""
plaque_key = None
bailout = 0
while plaque_key is None and bailout < 100:
bailout += 1
random_time = get_random_time()
if random_time is None:
plaque_key = None
else:
plaque_key = Plaque.query(
).filter(Plaque.approved == True
).filter(Plaque.created_on > random_time
).get(keys_only=True)
if plaque_key is None:
return None
else:
return plaque_key.urlsafe()
def get(self):
plaque_search_index = search.Index(PLAQUE_SEARCH_INDEX_NAME)
ideleted = 0
# Delete all the search documents
while True:
# Get a list of documents populating only the doc_id field and
# extract the ids.
document_ids = [
document.doc_id for document
in plaque_search_index.get_range(ids_only=True)]
ideleted += len(document_ids)
if not document_ids:
break
# Delete the documents for the given ids from the Index.
plaque_search_index.delete(document_ids)
logging.debug('deleted %s search index docs' % ideleted)
# Write all new search docs and put them in the index
plaques = Plaque.query().fetch()
docs = []
igood = 0
ibad = 0
for plaque in plaques:
try:
docs.append(plaque.to_search_document())
igood += 1
except search.Error as err:
ibad += 1
logging.error(err)
#if ip % 100 == 0:
#logging.debug('in process: wrote %s good docs, %s failed' % (
#igood, ibad))
iput = 0
for i in range(0, len(docs), 100):
iput += 100
plaque_search_index.put(docs[i:i+100])
self.response.write(
'deleted %s docs, created %s, failed to create %s, put %s' % (
ideleted, igood, ibad, iput))
def _create_or_update_plaque(self, is_edit, plaqueset_key):
"""
Create a new plaque entity if it does not exist, or update one if it
does.
"""
if not is_edit:
plaque = Plaque(parent=plaqueset_key)
else:
plaque_key = self.request.get('plaque_key')
plaque = ndb.Key(urlsafe=plaque_key).get()
location, created_by, title, description, img_name, img_fh, tags = \
self._get_form_args()
plaque.location = location
plaque.title = title
plaque.set_title_url(plaqueset_key, is_edit)
plaque.description = description
plaque.tags = tags
plaque.approved = users.is_current_user_admin()
plaque.updated_on = datetime.datetime.now()
# Upload the image for a new plaque, or update the image for an
# editted plaque, if specified.
is_upload_pic = (is_edit and img_name is not None) or (not is_edit)
if is_upload_pic:
self._upload_image(img_name, img_fh, plaque)
# Write to the updated_* fields if this is an edit:
#
if is_edit:
plaque.updated_by = users.get_current_user()
plaque.updated_on = datetime.datetime.now()
img_rot = self.request.get('img_rot')
if img_rot is not None and img_rot != 0:
plaque.img_rot = int(img_rot)
else:
plaque.created_by = created_by
plaque.updated_by = None
old_site_id = self.request.get('old_site_id', None)
if old_site_id is not None:
try:
plaque.old_site_id = int(old_site_id)
except ValueError as err:
logging.info('Eating bad ValueError for '
'old_site_id in AddPlaque')
plaque.put()
return plaque
def get_random_plaque_key(method='time'):
"""
Get a random plaque key. Limit to total number of runs to 100 to prevent
infinite loop if there are no plaques.
There are at least three strategies to get a random plaque:
1. Perform a Plaque.query().count(), get a random int in the [0,count)
range, and get the plaque at that offset using
Plaque.query.get(offset=foo).
This technique favors large submissions of plaques that were
imported automatically (e.g. North Carolina, Geographs,
Toronto/Ontario), and that large offsets are expensive in the NDB
system.
2. 'time': Pick a random time since the start of the site, and find a
plaque that has a created_by value close to that time.
This technique favors plaques which were submitted by users who have
submitted many plaques over a long period of time, and will be
unlikely to pick a plaque which would be picked by technique #1.
3. 'geo': Pick a random geographical spot on the globe, and get the
plaque closest to that.
This will favor plaques that are further away from other plaques.
"""
plaque_key = None
bailout = 0
plaque_search_index = search.Index(PLAQUE_SEARCH_INDEX_NAME)
while plaque_key is None and bailout < 100:
bailout += 1
if method == 'geo':
# Math from http://mathworld.wolfram.com/SpherePointPicking.html
rand_u = random.random()
rand_v = random.random()
lng = ((2.0 * rand_u) - 1.0) * 180.0 # Range: [-180.0, 180.0)
lat = math.acos(2.0 * rand_v - 1) * 180.0 / math.pi - 90.0
search_radius_meters = 100000 # 100 km
query_string = 'distance(location, geopoint(%s, %s)) < %s' % (
lat, lng, search_radius_meters)
query = search.Query(query_string)
results = plaque_search_index.search(query)
logging.info("bailout %s: produced results (%s)" %
(bailout, results))
if results.number_found > 0:
doc_id = results[0].doc_id
plaque_key = ndb.Key(doc_id).get()
else: #method == 'time'
random_time = get_random_time()
if random_time is not None:
plaque_key = Plaque.query().filter(
Plaque.approved == True).filter(
Plaque.created_on > random_time).get(keys_only=True)
if plaque_key is None:
return None
return plaque_key.urlsafe()
def get(self):
plaque = Plaque.pending_list(1)[0]
page_text = self._get_from_key(plaque_key=plaque.key.urlsafe())
self.response.write(page_text)
def _get_from_key(self, comment_key=None, plaque_key=None):
"""
Put the single plaque into a list for rendering so that the common
map functionality can be used unchanged. Attempt to serve a valid
plaque, but if the inputs are completely messed up, serve a random
plaque.
"""
is_admin = users.is_current_user_admin()
memcache_name = 'view_one_%s_%s' % (plaque_key, is_admin)
logging.info(
"memcache name in ViewOnePlaqueParent._get_from_key is %s" %
memcache_name)
page_text = memcache.get(memcache_name)
if page_text is None:
plaque = None
logging.info("plaque_key=%s" % plaque_key)
if comment_key is not None:
logging.debug("Using comment key")
comment = ndb.Key(urlsafe=comment_key).get()
plaque = Plaque.query().filter(Plaque.approved == True
).filter(Plaque.comments == comment.key
).get()
elif plaque_key is not None:
try:
logging.debug("Trying old_site_id")
old_site_id = int(plaque_key)
plaque = Plaque.query(
).filter(Plaque.approved == True
).filter(Plaque.old_site_id == old_site_id
).get()
except ValueError as err:
# Get by title, allowing only admins to see unapproved ones:
logging.debug("Using plaque.title_url: '%s'" % plaque_key)
query = Plaque.query().filter(Plaque.title_url == plaque_key)
if not users.is_current_user_admin():
query = query.filter(Plaque.approved == True)
logging.debug("query is %s " % query)
plaque = query.get()
if plaque is None:
try:
logging.debug("Using plaque_key: '%s'" % plaque_key)
plaque = ndb.Key(urlsafe=plaque_key).get()
logging.debug("Using plaque_key, "
"plaque retrieved was: '%s'" % plaque)
except:
pass
if plaque is None:
logging.debug("Neither comment_key nor plaque_key is specified. "
"Serve the first plaque, so that memcache will "
"always serve the same thing.")
plaque = earliest_approved(Plaque)
self.redirect(plaque.title_page_url)
return
template = JINJA_ENVIRONMENT.get_template('one.html')
template_values = get_default_template_values(
plaques=[plaque],
map_markers_str=get_map_markers_str([plaque]),
icon_size=32,
)
page_text = template.render(template_values)
memcache_status = memcache.set(memcache_name, page_text)
if not memcache_status:
logging.debug("memcaching for _get_from_key failed for %s" %
memcache_name)
else:
logging.debug("memcache.get worked for _get_from_key for %s" %
memcache_name)
return page_text
def _create_or_update_plaque(self, is_edit, plaqueset_key):
"""
Create a new plaque entity if it does not exist, or update one if it
does.
"""
if not is_edit:
plaque = Plaque(parent=plaqueset_key)
else:
plaque_key = self.request.get('plaque_key')
plaque = ndb.Key(urlsafe=plaque_key).get()
location, created_by, title, description, img_name, img_fh, tags = \
self._get_form_args()
plaque.location = location
if title != plaque.title:
plaque.title = title
plaque.set_title_url(plaqueset_key)
else:
plaque.title = title
plaque.description = description
plaque.tags = tags
if not is_edit:
plaque.approved = False
plaque.updated_on = datetime.datetime.now()
# Upload the image for a new plaque, or update the image for an
# editted plaque, if specified.
is_upload_pic = (is_edit and img_name is not None) or (not is_edit)
if is_upload_pic:
#TODO openbenches: disable upload here?
self._upload_image(img_name, img_fh, plaque)
# Write to the updated_* fields if this is an edit:
#
if is_edit:
plaque.updated_by = users.get_current_user()
plaque.updated_on = datetime.datetime.now()
img_rot = self.request.get('img_rot')
if img_rot is not None and img_rot != 0:
plaque.img_rot = int(img_rot)
else:
plaque.created_by = created_by
plaque.updated_by = None
old_site_id = self.request.get('old_site_id', None)
if old_site_id is not None:
try:
plaque.old_site_id = int(old_site_id)
except ValueError as err:
logging.info('Eating bad ValueError for '
'old_site_id in AddPlaque')
plaque.put()
return plaque
def get_pages_list(per_page=DEF_NUM_PER_PAGE):
num_pages = int(math.ceil(float(Plaque.num_approved()) /
float(per_page)))
pages_list = [1+p for p in range(num_pages)]
return pages_list