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 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, 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")