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 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, 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 get(self):
next = None
PAGESIZE = 30
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:
if user.user:
bookmark = Key.from_path('MySketchesSketch','-%023d' % (int(user.user_id)) + SKETCH_ZEROS)
else:
bookmark = Key.from_path('MySketchesSketch','-%023d' % (0) + SKETCH_ZEROS)
if user.user:
endKey = Key.from_path('MySketchesSketch','-%023d' % (int(user.user_id) + 1) + SKETCH_ZEROS)
else:
endKey = Key.from_path('MySketchesSketch','-%023d' % (1) + SKETCH_ZEROS)
logging.info('starting key ' + str(bookmark))
logging.info('starting key name' + bookmark.name())
q = db.GqlQuery("SELECT * FROM MySketchesSketch WHERE __key__ >= :1 AND __key__ < :2",bookmark,endKey)
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':"mySketches",
'headerTitle':"My sketches",
}
self.generate('galleryTemplate.html',template_values)
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 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):
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 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 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_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(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 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):
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 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 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, **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 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 get_dudle(id):
"""
Get dudle for id
"""
key = Key.from_path('Dudle', id)
dudle = Dudle.get(key)
return dudle
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, 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 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):
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 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 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 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 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 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):
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 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 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 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_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):
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 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 add_list_item(self, list_id, name, category, desc, url, is_surprise):
key = Key.from_path('ListDb', list_id)
return ListItemDb(
parent_list=key,
name=name,
category=category,
description=desc,
url=url,
is_surprise=is_surprise,
).put()
def get(self):
r = FlowerbedExplore()
user = users.get_current_user()
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
gamer = GqlQuery('SELECT * FROM Gamer WHERE ANCESTOR IS :1',
gamer_key).get()
if self.request.get('lat') and self.request.get('lon'):
r.timestamp = int(time.time())
lat = float(self.request.get('lat')) / 1000000
lon = float(self.request.get('lon')) / 1000000
gamer.point = GeoPt(lat, lon) #update user position
#take adjacent tiles
tiles = []
requests = []
tile = geocell.compute(GeoPt(lat, lon), RULES['GEO_RESOLUTION'])
tiles.append(tile)
tiles.extend(geocell.all_adjacents(tile))
kind = kloombaDb.Flowerbed.kind()
#prepare async requests
for i in tiles:
request = GqlQuery(
'SELECT * FROM Flowerbed WHERE ANCESTOR IS :1',
Key.from_path(kind, i)).run()
requests.append(request)
for i in requests:
for j in i:
fb = r.flowerbed.add()
fb.timestamp = int(time.mktime(j.timestamp.timetuple()))
fb.id = str(j.key())
fb.latitude = int(j.point.lat * 1000000)
fb.longitude = int(j.point.lon * 1000000)
fb.owner = j.owner_public_id
fb.flowers = j.flowers
gamer.put()
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
def get(self):
r = PossessionLost()
to_delete = []
poss = []
user = users.get_current_user()
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
possessions = GqlQuery(
'SELECT * FROM Possession WHERE ANCESTOR IS :1 AND lost = TRUE',
gamer_key).run()
r.timestamp = int(time.time())
for i in possessions:
if int(time.time()) - int(time.mktime(i.timestamp.timetuple())
) > RULES['LOST_FLOWERBED_TIMEOUT']:
to_delete.append(i.flowerbed.key())
else:
poss.append(i)
deleted = db.delete_async(to_delete)
if poss:
keys = [
kloombaDb.Possession.flowerbed.get_value_for_datastore(i)
for i in poss
]
flowerbeds = []
for i in keys:
fb = memcache.get(str(i))
if not fb:
fb = GqlQuery('SELECT * FROM Flowerbed WHERE __key__=:1',
i).get()
if fb and not memcache.add(str(i), fb):
logging.error('Memcache set failed')
if fb:
flowerbeds.append(fb)
for (p, f) in zip(poss, flowerbeds):
if p and f:
fb = r.possession.add()
fb.timestamp = int(time.mktime(p.timestamp.timetuple()))
fb.flowerbed.timestamp = int(
time.mktime(f.timestamp.timetuple()))
fb.flowerbed.id = str(f.key())
fb.flowerbed.latitude = int(f.point.lat * 1000000)
fb.flowerbed.longitude = int(f.point.lon * 1000000)
fb.flowerbed.owner = f.owner_public_id
fb.flowerbed.flowers = f.flowers
deleted.get_result()
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
def get_game_model(gameid=gid):
""" Return a Game model for the given game id.
Args:
gameid: The game id of the Game.
Returns:
The database model for the specified id or None if no such model
exists.
"""
return Game.get(Key.from_path('Game', gameid))
def get_game_model(gid):
""" Return a Game model for the given game id.
Args:
gid: The game id of the Game.
Returns:
The database model for the specified id or None if no such model
exists.
"""
game_key = Key.from_path('Game', gid)
model = db.get(game_key)
return model
def get_instance_model(gid, iid):
""" Return a GameInstance model for the given game and instance ids.
Args:
gid: The game id of the GameInstance.
iid: The instance id of the GameInstance.
Returns:
The database model for the specified ids or None if the
GameInstance doesn't exist..
"""
instance_key = Key.from_path('Game', gid, 'GameInstance', iid)
model = db.get(instance_key)
return model
def test_db_conversion(self):
actual_datetime = datetime.datetime.now()
entity = FieldsWithoutOptionsModel(
datetime=actual_datetime, date=actual_datetime.date(),
time=actual_datetime.time(), floating_point=5.97, boolean=True,
null_boolean=False, text='Hallo', email='*****@*****.**',
comma_seperated_integer="5,4,3,2",
ip_address='194.167.1.1', slug='you slugy s**t :)',
url='http://www.scholardocs.com', long_text=1000*'A',
indexed_text='hello', xml=2000*'B',
integer=-400, small_integer=-4, positiv_integer=400,
positiv_small_integer=4)
entity.save()
# get the gae entity (not the django model instance) and test if the
# fields have been converted right to the corresponding gae database types
gae_entity = Get(Key.from_path(FieldsWithoutOptionsModel._meta.db_table,
entity.pk))
for name, gae_db_type in [('long_text', Text),
('indexed_text', unicode), ('xml', Text),
('text', unicode), ('ip_address', unicode), ('slug', unicode),
('email', unicode),('comma_seperated_integer', unicode),
('url', unicode), ('time', datetime.datetime),
('datetime', datetime.datetime), ('date', datetime.datetime),
('floating_point', float), ('boolean', bool),
('null_boolean', bool), ('integer', (int, long)),
('small_integer', (int, long)), ('positiv_integer', (int, long)),
('positiv_small_integer', (int, long))]:
self.assertTrue(type(gae_entity[
FieldsWithoutOptionsModel._meta.get_field_by_name(
name)[0].column]) in (isinstance(gae_db_type, (list, tuple)) and \
gae_db_type or (gae_db_type, )))
# get the model instance and check if the fields convert back to the
# right types
entity = FieldsWithoutOptionsModel.objects.get()
for name, expected_type in [('long_text', unicode),
('indexed_text', unicode), ('xml', unicode),
('text', unicode), ('ip_address', unicode), ('slug', unicode),
('email', unicode), ('comma_seperated_integer', unicode),
('url', unicode), ('datetime', datetime.datetime),
('date', datetime.date), ('time', datetime.time),
('floating_point', float), ('boolean', bool),
('null_boolean', bool), ('integer', (int, long)),
('small_integer', (int, long)), ('positiv_integer', (int, long)),
('positiv_small_integer', (int, long))]:
self.assertTrue(type(getattr(entity, name)) in (isinstance(
expected_type, (list, tuple)) and expected_type or (expected_type, )))
def get(self, projectId, taskId, imageId):
taskId = int(taskId)
imageId = int(imageId)
projectId = int(projectId)
image = Image.get_by_id(
imageId, Key.from_path('Project', projectId, 'Task', taskId))
# figure out the mime type based on the filename
extension = os.path.splitext(image.filename)[1][1:]
mimeType = 'image/%s' % extension
self.response.headers['Cache-Control'] = 'max-age=2592000'
self.response.headers['Content-Type'] = mimeType
self.response.out.write(image.image)
def get(self):
# input marshalling
projectId = self.request.get('projectId')
tag = self.request.get('tag')
# grab the task for the projectId or tag
if len(projectId) > 0:
tasks = Task.AllTasksForProject(
Key.from_path('Project', int(projectId)))
taskList = [t.toDict() for t in tasks]
elif tag != None:
tasks = Task.AllTasksWithTag(tag)
taskList = [t.toDict() for t in tasks]
#self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(simplejson.dumps(taskList))
def post(self):
result = {'result': True, 'error': ''}
try:
# input marshalling
imageId = int(self.request.get('imageId'))
taskId = int(self.request.get('taskId'))
projectId = int(self.request.get('projectId'))
# grab the comment and kill it
image = Image.get_by_id(
imageId, Key.from_path('Project', projectId, 'Task', taskId))
image.delete()
except Exception, e:
result['result'] = False
result['error'] = 'Error: %s' % e
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 get(self):
result = {'result': True, 'error': ''}
# input marshalling
taskId = int(self.request.get('taskId'))
projectId = int(self.request.get('projectId'))
try:
# grab the task
task = Task.get_by_id(taskId, Key.from_path('Project', projectId))
result['task'] = task.toDict()
# add the comments and images
result['comments'] = [c.toDict() for c in task.comments]
result['images'] = [i.toDict() for i in task.images]
except Exception, e:
result['result'] = False
result['error'] = 'Error: %s' % e
def post(self):
result = {'result': True, 'error': ''}
try:
# input marshalling
taskId = int(self.request.get('taskId'))
projectId = int(self.request.get('projectId'))
completed = bool(self.request.get('completed'))
# grab the task
task = Task.get_by_id(taskId, Key.from_path('Project', projectId))
task.completed = completed
task.put()
result['data'] = task.toDict()
except Exception, e:
result['result'] = False
result['error'] = 'Error: %s' % e
def post(self):
result = {'result': True, 'error': ''}
try:
# input marshalling
taskId = int(self.request.get('taskId'))
projectId = int(self.request.get('projectId'))
# grab the task
task = Task.get_by_id(taskId, Key.from_path('Project', projectId))
task.removeAllComments()
task.removeAllImages()
task.delete()
result['data'] = task.toDict()
except Exception, e:
result['result'] = False
result['error'] = 'Error: %s' % e
def post(self):
result = {'result': True, 'error': ''}
try:
# input marshalling
projectId = int(self.request.get('projectId'))
taskId = int(self.request.get('taskId'))
comment = self.request.get('comment')
# grab the task
task = Task.get_by_id(taskId, Key.from_path('Project', projectId))
# create
c = Comment(parent=task, text=comment)
c.put()
result['data'] = c.toDict()
except Exception, e:
result['result'] = False
result['error'] = 'Error: %s' % e
def get(self):
r = BookmarkAdd()
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 flowerbed
flowerbed = GqlQuery('SELECT * FROM Flowerbed WHERE __key__=:1',
fb_key).get()
if not flowerbed:
return #no such flowerbed
#check bookmark
bookmark = GqlQuery(
'SELECT * FROM Bookmark WHERE ANCESTOR IS :1 AND flowerbed=:2',
gamer_key, Key(fb_key)).get()
if bookmark:
return #bookmark allready exist
bookmark = kloombaDb.Bookmark(parent=gamer_key)
bookmark.owner = user.user_id()
bookmark.flowerbed = flowerbed
bookmark.put()
r.timestamp = int(time.time())
fb = r.flowerbed
fb.timestamp = int(time.mktime(flowerbed.timestamp.timetuple()))
fb.id = str(flowerbed.key())
fb.latitude = int(flowerbed.point.lat * 1000000)
fb.longitude = int(flowerbed.point.lon * 1000000)
fb.owner = flowerbed.owner_public_id
fb.flowers = flowerbed.flowers
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
import hashlib
import logging
from google.appengine.ext.db import GqlQuery, Key
from blog.general_handler import GeneralHandler
from db.Highscore import Highscore
k = Key.from_path('Highscore', 'Content')
secret = 'jdks'
class TetrisHandler(GeneralHandler):
def get(self):
highscores = GqlQuery(
"SELECT * FROM Highscore WHERE ANCESTOR IS :1 ORDER BY highscore DESC",
k)
self.render('tetris.html', highscores=highscores)
def post(self):
name_html = self.get_user()
score_html = self.request.get('highscore_get')
speed_html = self.request.get('speed_get')
multiplier_html = self.request.get('multiplier_get')
hash_client = self.request.get('hash_get')
hash_server = hashlib.sha256(
str(score_html) + str(speed_html) + str(multiplier_html) +
secret).hexdigest()
if not name_html:
def get_game(iid, game_id):
key = Key.from_path('Game', gid, 'GameInstance', iid, 'Message', game_id)
return Message.get(key)
def guess_command(instance, player, arguments):
""" Evaluate a guess and determine the score.
Args:
instance: The GameInstance database model for this operation.
player: The player making the guess. Must be the leader of
the instance.
arguments: A two element list containg the game id and a second
list with the guessed colors.
new_game_command must be invoked before a guess can be made.
Returns:
If the player has guessed correctly:
A two element list containg a score list and a boolean of
whether or not this game set a new high score. The score list is
a three element list containing the player's high score, their
total score and their total number of games played.
Otherwise:
A four element list containing the player's remaining score, the
number of guesses remaining, the number of bulls for this guess
and the number of cows for this guess.
Raises:
ValueError if the player is not the current instance leader and
only member of the game.
ValueError if the player has no guesses remaining.
ValueError if the guess does not have the correct number of
elements.
ValueError if no game has been started yet.
"""
guess = arguments[1]
if len(guess) != solution_size:
raise ValueError("Guess was not the right number of elements.")
game = db.get(Key.from_path('Message', int(arguments[0]),
parent = instance.key()))
if game is None:
raise ValueError("Game not found. Please start a new game.")
if game.sender != player:
raise ValueError("This is not your game. Please start a new game.")
if guess == game.bac_last_guess:
return simplejson.loads(game.bac_last_reply)
if game.bac_guesses_remaining == 0:
raise ValueError("No turns left, please start a new game.")
return_content = None
if guess == game.bac_solution:
game.bac_guesses_remaining = 0
new_high_score = False
score = scoreboard.get_score(instance, player)
if game.bac_score > score[0]:
new_high_score = True
score[0] = game.bac_score
score[1] = score[1] + game.bac_score
score[2] = score[2] + 1
scoreboard.set_score(instance, player, score)
return_content = [score, new_high_score]
else:
game.bac_guesses_remaining -= 1
bulls = cows = 0
for i in xrange(solution_size):
if guess[i] == game.bac_solution[i]:
bulls += 1
elif guess[i] in game.bac_solution:
cows += 1
score_deduction = solution_size * 2 - cows - 2 * bulls
game.bac_score -= score_deduction
return_content = [game.bac_guesses_remaining, game.bac_score,
bulls, cows]
game.bac_last_reply = simplejson.dumps(return_content)
game.bac_last_guess = guess
game.put()
return return_content
def get(self):
user = self.user
# Try to get rendered output from memcache
rendered = memcache.get('dashboard-' + user.user_id)
if rendered and not settings.DEBUG:
return self.response.out.write(rendered)
# Fetch following users
following = user.following_users\
.order('name')\
.fetch(100)
user_keys = [user.key()] + [u.key() for u in following]
# Start async fetch of top recipes
top_recipes = Recipe.all()\
.filter('owner IN', user_keys)\
.order('-grade')\
.run(limit=15)
# Get and process interesting events
interesting_events = UserAction.all()\
.filter('owner IN', user_keys)\
.order('-created')\
.fetch(15)
object_ids = UserAction.gather_object_ids(interesting_events)
object_ids['users'] = [
id for id in object_ids['users']
if id not in [user.key().id()] + user.following
]
# Start async fetch of relevant recipes
recipes = db.get_async(
[Key.from_path('Recipe', id) for id in object_ids['recipes']])
# Start async fetch of relevant brews
brews = db.get_async(
[Key.from_path('Brew', id) for id in object_ids['brews']])
# Convert iterators to lists of items in memory and setup a map
# of user id -> user for easy lookups
following = list(following)
top_recipes = list(top_recipes)
user_map = {user.key().id(): user}
for u in following:
user_map[u.key().id()] = u
if object_ids['users']:
for u in UserPrefs.get_by_id(object_ids['users']):
user_map[u.key().id()] = u
# Setup a map of brew id -> brew for easy lookups
brew_map = {}
brew_recipe_ids = set()
for b in brews.get_result():
brew_recipe_ids.add(b.recipe_key.id())
brew_map[b.key().id()] = b
# Async fetch of any recipes brews reference that weren't
# included in the recipe fetch above...
brew_recipes = db.get_async([
Key.from_path('Recipe', id) for id in brew_recipe_ids
if id not in object_ids['recipes']
])
# Setup a map of recipe id -> recipe for easy lookups
recipe_map = {}
for r in recipes.get_result():
recipe_map[r.key().id()] = r
for r in brew_recipes.get_result():
recipe_map[r.key().id()] = r
# Render and cache for 1 minute
memcache.set(
'dashboard-' + user.user_id,
self.render(
'dashboard.html', {
'following': following,
'user_map': user_map,
'recipe_map': recipe_map,
'brew_map': brew_map,
'top_recipes': top_recipes,
'interesting_events': interesting_events
}), self.CACHE_TIME)
