def post(self):
model_kind = self.request.get('model_kind')
frequency = self.request.get('frequency')
date = str_to_date(self.request.get('date_string'))
store_key_name = self.request.get('store_key_name')
logging.info('Cleanupworker model kind: %s frequency: \
%s store: %s' % (model_kind, frequency, store_key_name))
recursion_flag = False
if model_kind == 'ProductRenderer':
store_key = Key.from_path('Store', store_key_name)
query = get_renderer_query_for_frequency(frequency, date,
store_key)
keys = query.fetch(200, TEMPLATE_PRODUCT_COUNT)
elif model_kind == 'ProductCounter':
store_key = Key.from_path('Store', store_key_name)
query = get_counter_query_for_frequency(frequency, date, store_key)
keys = query.fetch(200)
elif model_kind == 'UserCounter':
query = USER_COUNTER_CLEANUP_TARGETS
keys = query.fetch(200)
else:
logging.error('No type found for CleanupWorker :%s' % model_kind)
if len(keys):
recursion_flag = True
pdb.delete(keys)
if recursion_flag:
logging.info('Enqueing cleanup for model %s' % model_kind)
enqueue_cleanup(model_kind, frequency, str(date), store_key_name)
def get(self):
r = BookmarkRemove()
if not self.request.get('id'):
return
fb_key = self.request.get('id')
user = users.get_current_user()
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
#get bookmark
bookmark = GqlQuery(
'SELECT * FROM Bookmark WHERE ANCESTOR IS :1 AND flowerbed=:2',
gamer_key, Key(fb_key)).get()
if not bookmark:
return
bookmark.delete()
r.timestamp = int(time.time())
r.id = fb_key
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
def query_from_form(org, event, form, projection=None, distinct=None):
# start query based on admin type
if org.is_global_admin:
query = Query(Site, projection=projection, distinct=distinct)
elif org.is_local_admin:
if projection is not None or distinct is not None:
raise Exception("Not currently supported for local admin")
query = Query(Site).filter('event in', [
incident.key() for incident in org.incidents
])
else:
raise Exception("Not an admin")
# if a local admin, filter to logged in event
if org.is_local_admin:
query.filter('event', event.key())
# apply filters if set
if form.event.data:
query.filter('event', Key(form.event.data))
if form.reporting_org.data:
query.filter('reported_by', Key(form.reporting_org.data))
if form.claiming_org.data:
query.filter('claimed_by', Key(form.claiming_org.data))
if form.work_type.data:
query.filter('work_type', form.work_type.data)
if form.status.data:
query.filter('status', form.status.data)
# apply order
if form.order.data:
query.order(form.order.data)
return query
def post(self):
model_kind = self.request.get('model_kind')
frequency = self.request.get('frequency')
date = str_to_date(self.request.get('date_string'))
store_key_name = self.request.get('store_key_name')
logging.info('Cleanupworker model kind: %s frequency: \
%s store: %s' %(model_kind,frequency,store_key_name))
recursion_flag = False
if model_kind == 'ProductRenderer':
store_key = Key.from_path('Store',store_key_name)
query = get_renderer_query_for_frequency(frequency, date, store_key)
keys = query.fetch(200, TEMPLATE_PRODUCT_COUNT)
elif model_kind == 'ProductCounter':
store_key = Key.from_path('Store',store_key_name)
query = get_counter_query_for_frequency(frequency, date, store_key)
keys = query.fetch(200)
elif model_kind == 'UserCounter':
query = USER_COUNTER_CLEANUP_TARGETS
keys = query.fetch(200)
else:
logging.error('No type found for CleanupWorker :%s' %model_kind)
if len(keys):
recursion_flag = True
pdb.delete(keys)
if recursion_flag:
logging.info('Enqueing cleanup for model %s' %model_kind)
enqueue_cleanup(model_kind,frequency,str(date),store_key_name)
def get(self):
user = users.get_current_user()
r = FlowerbedAdd()
if self.request.get('lat') and self.request.get('lon'):
#TODO: check if flowerbed is far enough from others
#TODO: check if flowerbed is close enough to user
lat = int(self.request.get('lat')) / 1000000.0
lon = int(self.request.get('lon')) / 1000000.0
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
gamer_hash = hashlib.md5(user.user_id() + SALT).hexdigest()
r.timestamp = int(time.time())
#get backpack
bp_beds = GqlQuery('SELECT * FROM Backpack WHERE ANCESTOR IS :1 AND name=:2', gamer_key, 'flowerbed').get()
if bp_beds.amount:
#lower backpack
bp_beds.amount -= 1
bp_beds.put()
#add flowerbed
point = GeoPt(lat, lon)
cell = geocell.compute(point, RULES['GEO_RESOLUTION'])
flowerbed = kloombaDb.Flowerbed(parent=Key.from_path(kloombaDb.Flowerbed.kind(), cell))
flowerbed.point = point
flowerbed.tile = cell
flowerbed.owner = user.user_id()
flowerbed.owner_public_id = gamer_hash
flowerbed.put()
#save to memcache
memcache.set(str(flowerbed.key()), flowerbed)
#add possession
possession = kloombaDb.Possession(parent=gamer_key)
possession.flowerbed = flowerbed
possession.put()
backpack = GqlQuery('SELECT * FROM Backpack WHERE ANCESTOR IS :1', gamer_key).run()
#set timestamps
r.flowerbed.timestamp = int(time.time())
r.backpack.timestamp = int(time.time())
#set flowerbed
r.flowerbed.id = str(flowerbed.key())
r.flowerbed.latitude = int(self.request.get('lat'))
r.flowerbed.longitude = int(self.request.get('lon'))
r.flowerbed.owner = gamer_hash
r.flowerbed.flowers = 0
#set backpack
for i in backpack:
bp = r.backpack.item.add()
bp.name = i.name
bp.amount = i.amount
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
def get(self, key):
k = Key(encoded=key)
if k.kind() == 'NearWooCampaignDS':
logging.info('is this camp?????')
camp_obj = models.NearWooCampaignDS.urlsafe_get(key)
camp = camp_obj.to_dict()
# logging.info(camp.to_dict())
elif k.kind() == 'YelpJsonDS':
yelp = models.YelpJsonDS.urlsafe_get(key)
camp = models.NearWooCampaignDS.urlsafe_get(yelp.campaign_key)
elif k.kind() == 'Advertiser':
camp = models.NearWooCampaignDS.gql(
'where advertiser_key = :1', key).fetch(1000)
else:
camp = None
if not camp:
m = "Camp Entity cannot be retrieved with given key"
msg = make_status_message(success=False, message=m,
code=500, data=None)
self.response.write(msg)
else:
result = None
if type(camp) == list:
result = []
for c in camp:
result.append(c.to_dict())
else:
result = camp
msg = make_status_message(
success=True, message='successfully retrieved',
code=200, data=result)
self.response.write(msg)
def get(self):
user = users.get_current_user()
if user is None:
self.redirect(users.create_login_url(self.request.uri))
return
bookKey = Key(self.request.get('book'))
q = db.GqlQuery("SELECT * FROM Book WHERE __key__ = :1", bookKey)
book = q.get()
if book is None or book.userid != user.user_id():
self.redirect('/books.html')
return
else:
sheetKey = Key(self.request.get('sheet'))
q = db.GqlQuery("SELECT * FROM Sheet WHERE __key__ = :1", sheetKey)
sheet = q.get()
template_values = {
'book': book,
'sheet': sheet,
'mySection': 'active'
}
path = os.path.join(os.path.dirname(__file__), 'sheet.html')
self.response.out.write(template.render(path, template_values))
def post(self):
user = users.get_current_user()
if user is None:
self.redirect(users.create_login_url(self.request.uri))
return
bookKey = Key(self.request.get('book'))
q = db.GqlQuery("SELECT * FROM Book WHERE __key__ = :1", bookKey)
book = q.get()
if book is None or book.userid != user.user_id():
self.redirect('/books.html')
return
else:
sheetKey = Key(self.request.get('sheet'))
q = db.GqlQuery("SELECT * FROM Sheet WHERE __key__ = :1", sheetKey)
sheet = q.get()
if sheet.author.user_id() == user.user_id():
sheet.artist = self.request.get('artist')
sheet.song = self.request.get('song')
sheet.content = self.request.get('content')
sheet.put()
self.redirect('/sheet.html?book=' + str(book.key()) +
'&sheet=' + str(sheet.key()))
return
else:
self.redirect('/books.html')
return
def get(self, randomID):
NUMBER_OF_COMMENTS_PREVIEWED = 3
logging.info('you are doing a get to the latest comments downloader')
"""
if not authorized.checkIfUserIsInWhiteList():
self.redirect(authorized.getLoginPage())
"""
self.session = True
user = UserInfo()
user.whoIs(self)
startKey = Key.from_path('SketchComment',
"-" + randomID + "sketch00000000000000000000")
endKey = Key.from_path('SketchComment',
"-" + randomID + "sketch99999999999999999999")
# in the local environment
myModels = db.GqlQuery(
"SELECT * FROM SketchComment WHERE __key__ >= :1 AND __key__ < :2",
startKey, endKey).fetch(NUMBER_OF_COMMENTS_PREVIEWED + 1)
more = False
if len(myModels) == 4:
more = True
myModels = myModels[:3]
if len(myModels) == 0:
self.response.out.write("<br>no comments yet")
return
for myModel in myModels:
self.response.out.write('<div class="usercomments">')
self.response.out.write(
"<br /><strong><A class=timestamp-link href=\"/byUploader/" +
myModel.author_nickname + "-" + myModel.author_string_user_id +
"/\">" + myModel.author_nickname +
"</A> comment: </strong> <br />")
self.response.out.write(myModel.body.replace('\n', "<br>"))
self.response.out.write('<div class="commentdelete">')
# also check that the user is not anonymous before providing the delete link
if ((user.user)
and (myModel.author_user_id == user.user_id
or user.is_current_user_admin
or myModel.sketch_author_user_id == user.user_id)):
self.response.out.write(
'<A href=\"/deleteComment/' + myModel.key().name() +
'/?backTo=/view/' + randomID +
'/\"><img src="/imgs/delete.gif" alt="delete" height="25px" /> Delete</A>'
)
self.response.out.write('</div>')
self.response.out.write("</div><br />")
if more:
self.response.out.write(
"<p><A class=timestamp-link href=\"/comments/" + randomID +
"/\">more...</A></p>")
return
def post(self, key):
post = self.request.POST
form_data = dict(
(k, post.get(k, '')) for k in ('title', 'author', 'date', 'body'))
template_dict = {'form_data': form_data, 'key': key, 'show_form': True}
if 'delete_article' in post:
try:
NewsArticle.get(Key(key)).delete()
except datastore_errors.Error:
template_dict['message'] = \
'Could not delete article with key %r.' % key
else:
template_dict['message'] = 'Article deleted.'
template_dict['show_form'] = False
else:
try:
date = utils.parse_date(form_data['date'])
except ValueError:
template_dict['message'] = \
'Date is not in the correct format (YYYY-MM-DD).'
else:
if key == 'new':
try:
article = NewsArticle(title=form_data['title'],
author=form_data['author'],
date=date,
body=form_data['body'])
article.put()
except datastore_errors.Error:
template_dict['message'] = \
'Could not create new article.'
else:
template_dict['message'] = 'Article created.'
template_dict['show_form'] = False
else:
try:
article = NewsArticle.get(Key(key))
except BadKeyError:
template_dict['message'] = \
'Could not find article with key %r.' % key
else:
article.title = form_data['title']
article.author = form_data['author']
article.date = date
article.body = form_data['body']
try:
article.put()
except datastore_errors.Error:
template_dict['message'] = \
'Could not save changes to article.'
else:
template_dict['form_data'] = article
template_dict['message'] = 'Changes saved.'
self.render_template('edit', template_dict)
def get(self, **args):
cl = Checklist.get(Key.from_path("Checklist", long(args['id'])))
if not cl or cl.deleted:
helpers.createResponse(self, 'message_not_exist.html')
return
if not helpers.checkPermissionAndRespond(self, cl=cl, edit=False): return
item_q = cl.item_set.filter("deleted ==", False).order("creation_time")
cursor = self.request.get('cursor_item')
if cursor:
item_q = item_q.with_cursor(cursor)
items = item_q.fetch(20)
subs = []
for sub in cl.subscription_set:
subs.append(sub)
cursor_item = item_q.cursor()
item_q = item_q.with_cursor(cursor_item)
helpers.createResponse(self, 'dashboard_items.html',
{'items': items,
'cl': cl,
'cursor_item': cursor_item,
'more_items': item_q.count(1) == 1,
'subs': subs,
})
def get(self):
r = BookmarkRemove()
if not self.request.get('id'):
return
fb_key = self.request.get('id')
user = users.get_current_user()
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
#get bookmark
bookmark = GqlQuery('SELECT * FROM Bookmark WHERE ANCESTOR IS :1 AND flowerbed=:2', gamer_key, Key(fb_key)).get()
if not bookmark:
return
bookmark.delete()
r.timestamp = int(time.time())
r.id = fb_key
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
def post( self ):
result = {
'result': True,
'error': ''
}
try:
# input marshalling
projectId = int( self.request.get( 'projectId' ) )
taskId = int( self.request.get( 'taskId' ) )
filename = self.request.POST['Filedata'].filename
imageData = self.request.get( 'Filedata' )
# grab the task
task = Task.get_by_id( taskId, Key.from_path( 'Project', projectId ) )
# create
theImage = db.Blob( imageData )
i = Image( parent = task, filename = filename, image = theImage )
i.put()
result['data'] = i.toDict()
except Exception, e:
logging.error( e )
result['result'] = False
result['error'] = 'Error: %s' % e
def post(self):
cl = Checklist.get(Key.from_path('Checklist', long(self.request.get('cl_id'))))
if not helpers.checkPermissionAndRespond(self, cl=cl, edit=False):
return
user = users.get_current_user()
for sub in Subscription.all().filter("user ==", user).filter("deleted ==", False):
if sub.source.key() == cl.key():
helpers.createResponse(self, 'message_already_subscribed.html',
{'old_checklist': cl})
sub = Subscription(
user=user,
source=cl,
deleted=False,
)
sub.put()
for item in cl.item_set:
subItem = SubscribedItem(
subscription=sub,
original=item,
finished=False,
deleted=False,
)
subItem.put()
helpers.createResponse(self, 'message_subscribed.html')
def get(self):
mcode = self.request.get('mcode')
lcode = self.request.get('lcode')
q=Lecturer.all()
q.filter('__key__ =', Key.from_path('Lecturer', lcode))
lecturers = q.get()
self.response.write('Lecturer with code "'+lcode+'" is called "'+lecturers.full_name+'"')
q = Module.all()
q.filter('__key__ = ', Key.from_path('Module',mcode))
modules = q.get()
self.response.write('<br/>Module with code "'+modules.code+'" has title "'+modules.title+'"')
Rating(module=modules, lecturer =lecturers).put()
self.response.write('<br/> Rating probably put successfully')
def get(self):
condition = True
page = int(self.request.get('page')) if self.request.get('page') else 0
while condition:
condition = False # I want my do-while loops back!
off = int(self.request.get(
'page')) * SearchHandler.PER_PAGE if self.request.get(
'page') else 0
query = search.Query(
query_string=self.request.get('q'),
options=search.QueryOptions(
limit=SearchHandler.PER_PAGE,
ids_only=True,
number_found_accuracy=SearchHandler.PER_PAGE + 1,
offset=off))
results = Item.search_index().search(query)
arr = map(lambda x: Item.get(Key(x.doc_id)), results.results)
for result in arr:
if result.creation_time < Item.search_expiry_cutoff():
condition = True
Item.search_index().delete(str(result.key()))
self.render_template(
'items/search.html',
q=self.request.get('q'),
results=arr,
more_pages=((results.number_found - off) > SearchHandler.PER_PAGE),
fewer_pages=(page != 0),
per_page=SearchHandler.PER_PAGE,
page=page)
def post(self):
num = 0
for stop in settings.STOP_TYPES:
counter = StopMeta.get(Key.from_path('StopMeta', 1))
q = db.Query(Stop, keys_only=True).filter("stop_type =", stop).fetch(100)
logging.debug(q)
counter.counter_delta(-len(q), stop, "NO")
num += len(q)
db.delete(q)
q = db.Query(StopUpdate, keys_only=True).filter("stop_type =", stop).fetch(100)
logging.debug(q)
counter.counter_delta(-len(q), stop, "UPDATE")
num += len(q)
db.delete(q)
q = db.Query(StopNew, keys_only=True).filter("stop_type =", stop).fetch(100)
logging.debug(q)
counter.counter_delta(-len(q), stop, "NEW")
num += len(q)
db.delete(q)
counter.put()
if num:
taskqueue.add(url='/purge/delete', queue_name='import')
memcache.set('import_status', "Deletion finished.", time=30)
def post(self):
user = self.processPostData()
syllabusUnitIds = self.request.get_all('keys')
syllabusUnitKeys = [Key.from_path('SyllabusUnit', int(iid)) for iid in syllabusUnitIds]
user.syllabusUnitKeys = syllabusUnitKeys
user.put()
self.render(user)
def FileKey(filename, user):
if not user:
u_id = -1
else:
u_id = user.user_id()
return Key.from_path('File', '%s_%s' % (filename, u_id))
def get(self):
checklist = Checklist.get(Key.from_path('Checklist', long(self.request.get('cl_id'))))
if not helpers.checkPermissionAndRespond(self, cl=checklist): return
if not self.addable(checklist):
helpers.createResponse(self, 'message_can_not_create_item.html')
return
helpers.createResponse(self, 'create_item.html', {'checklist': checklist})
def ndfi_change(self, report_id, id):
r = Report.get(Key(report_id))
z, x, y = Cell.cell_id(id)
cell = Cell.get_or_default(r, x, y, z)
ee = ndfi = NDFI('MOD09GA', r.comparation_range(), r.range())
bounds = cell.bounds(amazon_bounds)
ne = bounds[0]
sw = bounds[1]
# spcify lon, lat F**K, MONKEY BALLS
polygons = [[(sw[1], sw[0]), (sw[1], ne[0]), (ne[1], ne[0]),
(ne[1], sw[0])]]
cols = 1
rows = 1
if z < 2:
cols = rows = 10
data = ndfi.ndfi_change_value(r.base_map(), [polygons], rows, cols)
logging.info(data)
ndfi = data['data'] #data['data']['properties']['ndfiSum']['values']
if request.args.get('_debug', False):
ndfi['debug'] = {
'request': ee.ee.last_request,
'response': ee.ee.last_response
}
return Response(json.dumps(ndfi), mimetype='application/json')
def get_news_item(id):
if 'uncached' not in request.args:
return get_news_item_cached(id)
key = Key.from_path('NewsItem', str(id))
news_item = NewsItem.get(key)
return Response(json.dumps(news_item.jsonData, default=dthandler), mimetype='application/json')
def post_news_item(news_item_id=None):
if not users.is_current_user_admin():
abort(401)
if news_item_id:
key = Key.from_path('NewsItem', str(news_item_id))
news_item = NewsItem.get(key)
news_item.clearTags();
else:
news_item = NewsItem.create()
# TODO: Most of this code can go in the model with a fromJSONData function
news_item.title = request.json['title']
news_item.body = request.json['body']
news_item.draft = request.json['draft']
news_item.posted_date = parser.parse(request.json['posted_date'])
news_item.last_modified_date = parser.parse(request.json['last_modified_date'])
news_item.put();
# Loop through the tags to add them
for tag_name in request.json['tags']:
tag_name = tag_name.strip()
if tag_name == '':
continue
tag = Tag(key_name=tag_name, tag=tag_name)
tag.put()
news_item_tag = NewsItemTag()
news_item_tag.tag = tag.key()
news_item_tag.news_item = news_item.key()
news_item_tag.put()
return Response(json.dumps(news_item.jsonData, default=dthandler), mimetype='application/json')
def children(self, report_id, id):
r = Report.get(Key(report_id))
z, x, y = Cell.cell_id(id)
cell = Cell.get_or_default(r, x, y, z)
cells = cell.children()
return self._as_json(
[x.as_dict() for x in cells if not self.is_in_backlist(x)])
def FileKey(filename, user):
if not user:
u_id = -1
else:
u_id = user.user_id()
return Key.from_path('File', '%s_%s' % (filename, u_id))
def get_dudle(id):
"""
Get dudle for id
"""
key = Key.from_path('Dudle', id)
dudle = Dudle.get(key)
return dudle
def post(self):
store_key_name = self.request.get('store_key_name')
date = str_to_date(self.request.get('date_string'))
frequency = self.request.get('frequency')
renderers = []
store_key = Key.from_path('Store', store_key_name)
query = get_counter_query_for_frequency(frequency, date, store_key)
product_counters = query.fetch(TEMPLATE_PRODUCT_COUNT)
key_names = [counter.key().name() for counter in product_counters]
product_renderers = ProductRenderer.get_by_key_name(
key_names, _storage=[MEMCACHE, DATASTORE], _result_type=NAME_DICT)
for counter in product_counters:
renderer = product_renderers[counter.key().name()]
try:
renderer.count = counter.count
renderers.append(renderer)
except AttributeError: #Renderer is none
renderer = ProductRenderer.build(counter.key_root,
frequency,
date,
count=counter.count)
if renderer is not None: #building from existing renderers successful
renderers.append(renderer)
else:
enqueue_renderer_info(counter.key_root, counter.count,
frequency, date)
if len(renderers):
pdb.put(renderers, _storage=[MEMCACHE, DATASTORE])
def list(self, report_id):
r = Report.get(Key(report_id))
cell = Cell.get_or_default(r, 0, 0, 0)
return self._as_json([
x.as_dict() for x in iter(cell.children())
if not self.is_in_backlist(x)
])
def get(self):
str_id = self.request.get('id')
message = self.request.get('message')
if not str_id or not message:
self.response.status_int = 400
self.response.body = "Invalid or missing id and or message."
return
devices = GqlQuery('SELECT * FROM Device WHERE __key__ = :1',
Key.from_path('Device', str_id))
if devices.count() < 1:
self.response.status_int = 404
self.response.body = "Target device not registered."
return
payload = {'registration_ids': [devices.get().token], 'data': {'message': message}}
headers = {'Content-Type': 'application/json',
'Authorization': 'key=' + API_KEY}
result = urlfetch.fetch(url = ANDROID_GCM_URL,
payload = json.dumps(payload),
method = urlfetch.POST,
headers = headers)
self.response.status_int = result.status_code
self.response.body = result.content
def get(self, **args):
cl = Checklist.get(Key.from_path("Checklist", long(args['id'])))
if not cl or cl.deleted:
helpers.createResponse(self, 'message_not_exist.html')
return
if not helpers.checkPermissionAndRespond(self, cl=cl, edit=False): return
item_q = cl.item_set.filter("deleted ==", False).order("creation_time")
cursor = self.request.get('cursor')
if cursor:
item_q = item_q.with_cursor(cursor)
items = item_q.fetch(20)
user = users.get_current_user()
subscribed = False
for sub in Subscription.all().filter("user ==", user).filter("deleted ==", False):
if sub.source.key() == cl.key():
subscribed = True
break
helpers.createResponse(self, 'dashboard_subscribe.html',
{'items': items,
'cl': cl,
'cursor_item': item_q.cursor(),
'subscribed': subscribed,
},
)
def AddAssignmentUsers(assignment, selectedUsers, serverhost, requestUri):
settings = GetSettings()
domain = GetAppsDomain()
invitees = []
failedInvitees = []
failedemails = []
for su in selectedUsers:
up = None
if su['type'] == 'appuser':
up = GetUserProfileFromUserId(Key(su['key']))
else:
up = GetUserProfileFromEmail(su['key'])
if up is None:
up = UserProfile()
up.fname = su['fname']
up.lname = su['lname']
up.email = su['key']
up.accesslevel = "0"
if settings.defaultavatar:
up.userimage = settings.defaultavatar
up.put()
#create registration
try:
#logging.info ('adding reg for ' + up.email)
regid = CreateNewRegistration(up.key(), assignment.courseid,
assignment.key())
invitees.append(up.email)
except ScormCloudError, instance:
logging.error("SC Error creating Registation: " + instance.msg)
failedInvitees.append(up.email)
except Exception, e:
logging.error("Error creating Registation: " + str(e.args))
failedInvitees.append(up.email)
def get(self, room_slug, message_key):
room = Room.get_by_key_name(room_slug)
if not room:
self.error(404)
self.response.out.write("no such room")
return
message = Message.all().filter('__key__ =', Key(message_key), 'room =',
room).get()
if not message:
self.error(404)
self.response.out.write("no such message")
return
message = transform_message(message)
url = "/api/"
sender_url = url + "account/" + str(message.sender.key())
room_url = url + "room/" + str(message.room.key().name())
payload = {
'timestamp': message.timestamp.isoformat(),
'content': message.content,
'sender': sender_url,
'room': room_url,
'event': Message_event_names[message.event],
'extra': extra,
'id': message.key().id()
}
json = simplejson.dumps(payload)
self.response.out.write(json)
def get(self):
r = BookmarkList()
keys = []
user = users.get_current_user()
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
bookmarks = GqlQuery('SELECT * FROM Bookmark WHERE ANCESTOR IS :1',
gamer_key).run()
r.timestamp = int(time.time())
for i in bookmarks:
keys.append(i.flowerbed.key())
flowerbeds = kloombaDb.Flowerbed.get(keys) if keys else []
for i in flowerbeds:
fb = r.flowerbed.add()
fb.timestamp = int(time.mktime(i.timestamp.timetuple()))
fb.id = str(i.key())
fb.latitude = int(i.point.lat * 1000000)
fb.longitude = int(i.point.lon * 1000000)
fb.owner = i.owner_public_id
fb.flowers = i.flowers
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
def event_key_coerce(x):
if type(x) is event_db.Event:
return x.key()
elif type(x) is Key:
return x
else:
return Key(x)
def get(self):
r = BookmarkList()
keys = []
user = users.get_current_user()
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
bookmarks = GqlQuery('SELECT * FROM Bookmark WHERE ANCESTOR IS :1', gamer_key).run()
r.timestamp = int(time.time())
for i in bookmarks:
keys.append(i.flowerbed.key())
flowerbeds = kloombaDb.Flowerbed.get(keys) if keys else []
for i in flowerbeds:
fb = r.flowerbed.add()
fb.timestamp = int(time.mktime(i.timestamp.timetuple()))
fb.id = str(i.key())
fb.latitude = int(i.point.lat * 1000000)
fb.longitude = int(i.point.lon * 1000000)
fb.owner = i.owner_public_id
fb.flowers = i.flowers
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
def get(self, login_user=None, template_values={}):
# is import or update going on?
template_values['update_status'] = memcache.get('update_status')
template_values['import_status'] = memcache.get('import_status')
# Check for existing data.
try:
counter = StopMeta.get(Key.from_path('StopMeta', 1))
template_values['production_num_stops'] = counter.counter_stop_no_confirm
template_values['production_num_stations'] = counter.counter_station_no_confirm
template_values['production_num_places'] = counter.counter_place_no_confirm
# confirmation outstanding
template_values['update_num_stops'] = counter.counter_stop_update_confirm
template_values['update_num_stations'] = counter.counter_station_update_confirm
template_values['update_num_places'] = counter.counter_place_update_confirm
template_values['new_num_stops'] = counter.counter_stop_new_confirm
template_values['new_num_stations'] = counter.counter_station_new_confirm
template_values['new_num_places'] = counter.counter_place_new_confirm
# Administrative hierarchy
template_values['gov_num'] = Comuna.all().count()+Region.all().count()+Country.all().count()
except AttributeError:
# no data in database. Redirect to import page
self.redirect('/import')
template_values['upload_url'] = blobstore.create_upload_url('/update/upload')
path = os.path.join(os.path.dirname(__file__), "pages/update.html")
self.response.out.write(template.render(path, template_values))
return
def post(self):
store_key_name = self.request.get('store_key_name')
date = str_to_date(self.request.get('date_string'))
frequency = self.request.get('frequency')
renderers = []
store_key = Key.from_path('Store',store_key_name)
query = get_counter_query_for_frequency(frequency, date, store_key)
product_counters = query.fetch(TEMPLATE_PRODUCT_COUNT)
key_names = [counter.key().name() for counter in product_counters ]
product_renderers = ProductRenderer.get_by_key_name(key_names,
_storage=[MEMCACHE,DATASTORE],
_result_type=NAME_DICT)
for counter in product_counters:
renderer = product_renderers[counter.key().name()]
try:
renderer.count = counter.count
renderers.append(renderer)
except AttributeError: #Renderer is none
renderer = ProductRenderer.build(counter.key_root,
frequency, date,count = counter.count)
if renderer is not None: #building from existing renderers successful
renderers.append(renderer)
else:
enqueue_renderer_info(counter.key_root,
counter.count,
frequency,
date)
if len(renderers):
pdb.put(renderers, _storage=[MEMCACHE,DATASTORE])
def post( self ):
result = {
'result': True,
'error': ''
}
try:
# input marshalling
taskId = int( self.request.get( 'taskId' ) )
projectId = int( self.request.get( 'projectId' ) )
title = self.request.get( 'title' )
description = self.request.get( 'description' )
tagJson = unicode( self.request.get( 'tags' ) )
tags = simplejson.loads( tagJson ) # should be an array!
# add the new tags in case we don't have them already
Tags.InsertIfNotHere( users.GetCurrentUser(), tags )
# grab the task
task = Task.get_by_id( taskId, Key.from_path( 'Project', projectId ) )
task.title = title
task.description = description
task.tags = tags
task.put()
result['data'] = task.toDict()
except Exception, e:
result['result'] = False
result['error'] = 'Error: %s' % e
def make_db_key(key):
path = reduce(
operator.add,
(('Slot', '/'.join(key[:i + 1])) for i in range(len(key))),
()
)
return Key.from_path(*path)
def landsat(self, report_id, id):
r = Report.get(Key(report_id))
z, x, y = Cell.cell_id(id)
cell = Cell.get_or_default(r, x, y, z)
bounds = cell.bounds(amazon_bounds)
bounds = "%f,%f,%f,%f" % (bounds[1][1], bounds[1][0], bounds[0][1],
bounds[0][0])
ee = EELandsat(LANDSAT7)
d = ee.list(bounds=bounds)
data = {}
if len(d) >= 1:
x = d[-1]
img_info = x.split('/')[2][3:]
path = img_info[:3]
row = img_info[3:6]
year = int(img_info[6:10])
julian_date = img_info[10:13]
date = date_from_julian(int(julian_date), year)
data = {
'info': img_info,
'path': path,
'row': row,
'year': year,
'timestamp': timestamp(date),
'date': date.isoformat()
}
return Response(json.dumps(data), mimetype='application/json')
def post(self):
result = {'result': True, 'error': ''}
try:
# input marshalling
taskId = int(self.request.get('taskId'))
projectId = int(self.request.get('projectId'))
title = self.request.get('title')
description = self.request.get('description')
tagJson = unicode(self.request.get('tags'))
tags = simplejson.loads(tagJson) # should be an array!
# add the new tags in case we don't have them already
Tags.InsertIfNotHere(users.GetCurrentUser(), tags)
# grab the task
task = Task.get_by_id(taskId, Key.from_path('Project', projectId))
task.title = title
task.description = description
task.tags = tags
task.put()
result['data'] = task.toDict()
except Exception, e:
result['result'] = False
result['error'] = 'Error: %s' % e
def ndfi_value_for_cells(cell_key):
cell = Cell.get(Key(cell_key))
ndfi = NDFI('MOD09GA', cell.report.comparation_range(),
cell.report.range())
bounds = cell.bounds(amazon_bounds)
logging.info(bounds)
ne = bounds[0]
sw = bounds[1]
polygons = [[(sw[1], sw[0]), (sw[1], ne[0]), (ne[1], ne[0]),
(ne[1], sw[0])]]
data = ndfi.ndfi_change_value(cell.report.base_map(), [polygons])
logging.info(data)
if 'data' not in data:
logging.error("can't get ndfi change value")
return
ndfi = data['data']['properties']['ndfiSum']['values']
for row in xrange(10):
for col in xrange(10):
idx = row * 10 + col
count = float(ndfi['count'][idx])
s = float(ndfi['sum'][idx])
if count > 0.0:
ratio = s / count
else:
ratio = 0.0
ratio = ratio / 10.0 #10 value is experimental
# asign to cell
logging.info('cell ndfi (%d, %d): %f' % (row, col, ratio))
c = cell.child(row, col)
c.ndfi_change_value = ratio
c.put()
def AuthenticatedGet(self, org, event):
form = OrganizationFilterForm(self.request.GET)
# get relevant organizations and incidents
if org.is_global_admin:
query = organization.Organization.all()
events = event_db.Event.all()
elif org.is_local_admin:
query = organization.Organization.all().filter(
'incidents', event.key())
events = [event]
form.event.choices = [('', 'All')] + [(e.key(), e.name)
for e in events]
# apply filters
if form.event.data:
query.filter('incidents', Key(form.event.data))
if form.active.data is not None:
query.filter('is_active', form.active.data)
if form.verified.data is not None:
query.filter('org_verified', form.verified.data)
if form.logged_in_days.data is not None:
earliest_date = (
datetime.datetime.utcnow() -
datetime.timedelta(days=int(form.logged_in_days.data)))
query.filter('timestamp_login >=', earliest_date)
self.render(
form=form,
org_query=query,
url="/admin-edit-organization?organization=",
global_admin=org.is_global_admin,
)
def restate_user():
user = db.get(Key.from_path("User", "n:" + nonce))
if not user:
return None
user.atime = datetime.now()
user.state = 0
user.put()
return user
def chicken_user():
user = db.get(Key.from_path("User", "n:" + playerid))
if not user:
return None
user.atime = datetime.now()
user.state = 9
user.put()
return user
def list(self, report_id, cell_pos):
r = Report.get(Key(report_id))
z, x, y = Cell.cell_id(cell_pos)
cell = Cell.get_cell(r, x, y, z)
notes = []
if cell:
return self._as_json([x.as_dict() for x in cell.note_set])
return self._as_json([])
def list(self, report_id, cell_pos):
r = Report.get(Key(report_id))
z, x, y = Cell.cell_id(cell_pos)
cell = Cell.get_cell(r, x, y, z)
if not cell:
return self._as_json([])
else:
return self._as_json([x.as_dict() for x in cell.area_set])
def delete(self, report_id, cell_pos, id):
a = Area.get(Key(id))
if a:
a.delete()
a = Response("deleted", mimetype='text/plain')
a.status_code = 204
return a
abort(404)
def get(self):
next = None
PAGESIZE = 30
util.insertUsersideCookies(self)
user = UserInfo()
user.whoIs(self)
if user.email == '*****@*****.**':
self.generate('limboPage.html')
return;
bookmark = self.request.get("bookmark")
if bookmark:
bookmark = Key(self.request.get("bookmark"))
else:
bookmark = Key.from_path('GallerySketch',SKETCH_ZEROS)
logging.info('starting key ' + str(bookmark))
logging.info('starting key name' + bookmark.name())
q = db.GqlQuery("SELECT * FROM GallerySketch WHERE __key__ >= :1", bookmark)
sketches = q.fetch(PAGESIZE+1)
if len(sketches) == PAGESIZE + 1:
next = str(sketches[-1].key())
sketches = sketches[:PAGESIZE]
logging.info('next key ' + next)
logging.info('next key name ' + sketches[-1].key().name())
if next is None:
next = ""
for sketch in sketches:
sketch.stringtags = util.shorten(" ".join(sketch.tags),18)
template_values = {
'sketches':sketches,
'bookmark':bookmark,
'next':next,
'action':"gallery",
'headerTitle':"Gallery",
}
self.generate('galleryTemplate.html',template_values)
def delete_news_item(news_item_id):
if not users.is_current_user_admin():
abort(401)
# Don't use get_by_id here since this can be a draft and that function
# doesn't return draft items
key = Key.from_path('NewsItem', str(news_item_id))
news_item = NewsItem.get(key)
news_item.delete()
return Response(json.dumps({}), mimetype='application/json')
def get_comments(news_item_id):
key = Key.from_path('NewsItem', str(news_item_id))
# Don't use get_by_id here since this can be a draft and that function
# doesn't return draft items
news_item = NewsItem.get(key)
news_item.add_meta_fields()
comments = news_item.sorted_comments()
p = [x.jsonData for x in comments]
return Response(json.dumps(p, default=dthandler), mimetype='application/json')
def delete(self, id):
u = get_user()
if u is None:
abort(404, message="User not found.")
f = Favorites.all().filter('user', u).filter('beer', Key.from_path('Beer', id)).get()
if f is None:
abort(404, message="Favorite not found")
f.delete()
return {'favorite': marshal(f, favorite_fields), 'action': 'deleted'}
def get_dudlr_by_id(id):
"""
Get dudlr by id.
@param id: numeric id of the C{Dudlr}
"""
key = Key.from_path('Dudlr', id)
dudlr = Dudlr.get(key)#Dudlr.all().filter('name = ', name).get()
return dudlr
def handle_login():
acct = db.get(Key.from_path("Account", "n:" + name))
if not acct:
acct = Account(key_name="n:" + name, level=level,
nonce="%X" % random.getrandbits(64))
acct.put()
return acct.nonce
else:
return ""
def get(self,randomID):
next = None
PAGESIZE = 5
"""
if not authorized.checkIfUserIsInWhiteList():
self.redirect(authorized.getLoginPage())
"""
util.insertUsersideCookies(self)
self.session = True
user = UserInfo()
user.whoIs(self)
bookmark = self.request.get("bookmark")
if bookmark:
bookmark = Key(self.request.get("bookmark"))
else:
bookmark = Key.from_path('SketchComment',"-" + randomID + 'sketch00000000000000000000')
endKey = Key.from_path('SketchComment',"-" + randomID + 'sketch99999999999999999999')
q = db.GqlQuery("SELECT * FROM SketchComment WHERE __key__ >= :1 AND __key__ < :2", bookmark, endKey)
sketchComments = q.fetch(PAGESIZE+1)
if len(sketchComments) == PAGESIZE + 1:
next = str(sketchComments[-1].key())
sketchComments = sketchComments[:PAGESIZE]
if next is None:
next = ""
for sketchComment in sketchComments:
sketchComment.keyname = sketchComment.key().name()
template_values = {
'sketchComments':sketchComments,
'bookmark':bookmark,
'next':next,
'randomID':randomID,
}
self.generate('commentsTemplate.html',template_values)
def create(self, report_id, cell_pos):
r = Report.get(Key(report_id))
z, x, y = Cell.cell_id(cell_pos)
cell = Cell.get_or_create(r, x, y, z)
data = json.loads(request.data)
if 'msg' not in data:
abort(400)
a = Note(msg=data['msg'], added_by=users.get_current_user(), cell=cell)
a.save()
return Response(a.as_json(), mimetype='application/json')
def update(self, report_id, cell_pos, id):
data = json.loads(request.data)
a = Area.get(Key(id))
a.geo = json.dumps(data['paths'])
a.type = data['type']
a.added_by = users.get_current_user()
a.save()
return Response(a.as_json(), mimetype='application/json')
def rgb_mapid(self, report_id, id, r, g, b):
report = Report.get(Key(report_id))
z, x, y = Cell.cell_id(id)
cell = Cell.get_or_default(report, x, y, z)
ndfi = NDFI('MOD09GA', report.comparation_range(), report.range())
poly = cell.bbox_polygon(amazon_bounds)
mapid = ndfi.rgb_strech(poly, tuple(map(int, (r, g, b))))
if 'data' not in mapid:
abort(404)
return Response(json.dumps(mapid['data']), mimetype='application/json')
def post(self):
password = self.request.POST.get("password")
hashed = getHash(password)
key = self.session.get('key')
key_obj = Key(key)
user = db.get(key_obj)
user.password = hashed
user.put()
self.redirect("/list")
