def migrate_to_0_2(request): #added: # page # room.main_page # content.page # 1. Add a main page to each room roomsQ = GqlQuery("SELECT * FROM Room") for room in roomsQ: mp = Page() mp.room = str(room.key()) mp.title = "Home" mp.put() room.main_page = str(mp.key()) room.put() # 2. set all content for that room to the page contentsQ = GqlQuery( "SELECT * FROM Content WHERE ANCESTOR is :room_key", room_key=room.key()) for c in contentsQ: c.parent = room.main_page c.page = room.main_page c.room = None c.put() return HttpResponse('Migration to 0.2 Successful')
def get(self, post_id): key = db.Key.from_path('Posts', int(post_id)) post = db.get(key) keyTwo = db.Key.from_path('Users', int(post.owner)) owner = db.get(keyTwo) comments = GqlQuery('select * from Comments where post_id = ' + post_id) likes = GqlQuery('select * from PostLikes where post_id = ' + post_id) liked = 'no' for l in likes: if l.ownerName == self.user.username: liked = 'yes' if not post: self.error(404) return return self.render('blog-post.html', post=post, comments=comments, likes=likes, owner=owner, liked=liked, you=self.user)
def _stats(): if not (users.is_current_user_admin() or users.get_current_user().email().endswith('@fogcreek.com') or request.remote_addr in ['127.0.0.1', '71.190.247.30']): abort(404) user_count = GqlQuery('SELECT __key__ FROM UserSettings').count(None) site_count = GqlQuery( 'SELECT __key__ FROM Site WHERE example=false').count(None) now = datetime.now() days = list(reversed([now - timedelta(days) for days in range(14)])) day_views = [ get_period_and_count('css:all', PeriodType.DAY, day) for day in days ] day_users = [ get_period_and_count('user:all', PeriodType.DAY, day) for day in days ] day_sites = [ get_period_and_count('site:all', PeriodType.DAY, day) for day in days ] # overwrite today's cached numbers with the live count we just got from the database day_users[-1] = day_users[-1][0], user_count day_sites[-1] = day_sites[-1][0], site_count # get the top referrers period_type = PeriodType.DAY fetch_limit = 50 query = LivecountCounter.all().order('-count') query.filter('period_type = ', period_type) query.filter('period = ', PeriodType.find_scope(period_type, datetime.now())) top_counters = query.fetch(fetch_limit) top_referrers = [] for counter in top_counters: name = counter.name if name.startswith('css:page') and not name.startswith( 'css:page:www.webputty.net'): parts = name.split(':') page = None preview_size = 0 published_size = 0 try: page = Page.get(parts[3]) except Exception: logging.warn("_stats counldn't find matching page: %s", parts[3]) if page: preview_size = len(page.compressed_css(True)) published_size = len(page.compressed_css(False)) top_referrers.append((parts[2], counter.count, parts[3], preview_size, published_size)) return render_template('_stats.html', user_count=user_count, site_count=site_count, day_views=day_views, day_users=day_users, day_sites=day_sites, top_referrers=top_referrers)
def _checkProposedScheduleValidity(self, proposedStartTS, req=''): proposedStartTS = int(proposedStartTS) logging.info(proposedStartTS) q = GqlQuery( "SELECT * FROM Repair where status=:astatus and isScheduled=:isTrue and scheduleStart<:psTS order by scheduleStart desc", psTS=proposedStartTS, astatus='INCOMPLETE', isTrue=True) isOk = True prevRepair = None for arepair in q.run(limit=1): prevRepair = arepair if proposedStartTS - arepair.scheduleStart < REPAIRSLOTTIME: isOk = False q = GqlQuery( "SELECT * FROM Repair where status=:astatus and isScheduled=:isTrue and scheduleStart>=:psTS order by scheduleStart asc", psTS=proposedStartTS, astatus='INCOMPLETE', isTrue=True) tuples = [] for arepair in q.run(limit=24): tuples.append(arepair) if len(tuples) > 0: if tuples[0].scheduleStart - proposedStartTS < REPAIRSLOTTIME: isOk = False logging.info(len(tuples)) if isOk: return 'OK' for k in range(1, len(tuples)): if tuples[k].scheduleStart - tuples[ k - 1].scheduleStart >= REPAIRSLOTTIME: nextSlot = self._getnextAvailableSlot(tuples[k - 1].scheduleStart) logging.info('in next poo') logging.info(nextSlot) return 'Next available slot is from ' + nextSlot if len(tuples) < 24 and len(tuples) > 0: nextSlot = self._getnextAvailableSlot(tuples[len(tuples) - 1].scheduleStart) logging.info('in next') logging.info(nextSlot) return 'Next available slot is from ' + nextSlot if len(tuples) == 0: nextSlot = self._getnextAvailableSlot(prevRepair.scheduleStart) logging.info('in prev') logging.info(nextSlot) return 'Next available slot is from ' + nextSlot return 'No available slot withing 24 hours from proposed slot'
def stats_cron(): current_user_count = GqlQuery('SELECT __key__ FROM UserSettings').count(None) current_site_count = GqlQuery('SELECT __key__ FROM Site WHERE example=false').count(None) now = datetime.now() saved_user_count = counter.load_and_get_count('user:all', period_type=PeriodType.DAY, period=now) or 0 saved_site_count = counter.load_and_get_count('site:all', period_type=PeriodType.DAY, period=now) or 0 count_view('user:all', delta=(current_user_count - saved_user_count), batch_size=None, period=now) count_view('site:all', delta=(current_site_count - saved_site_count), batch_size=None, period=now) return render_template('_stats_cron.html', current_user_count=current_user_count, current_site_count=current_site_count, saved_user_count=saved_user_count, saved_site_count=saved_site_count)
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(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 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 addFile(self): htmlHelper.SetContentTypeToXml(self) currUser = datamodule.GetUser(self.request.get('userName'), self.request.get('password')) if (not currUser): self.response.out.write( htmlHelper.XmlDeclaration + '<error errorId="4">User not found</error>') return filename = self.request.get('fileName').strip() if len(filename) == 0: self.response.out.write( htmlHelper.XmlDeclaration + '<error errorId="5">File name required</error>') return existingFile = GqlQuery( 'SELECT __key__ FROM Files WHERE user = :1 AND fileName = :2', currUser, filename).get() if existingFile: self.response.out.write( htmlHelper.XmlDeclaration + '<error errorId="6">File name not unique</error>') return file = datamodule.Files(user=currUser, fileName=filename, fileText=self.request.get('fileText')) file.put() self.response.out.write(htmlHelper.XmlDeclaration + '<OK>File Added</OK>')
def get(self): if self.user: userID = str(self.user.key().id()) posts = GqlQuery('select * from Posts where owner = ' + userID) return self.render('profile.html', you=self.user, posts=posts) else: return self.redirect('/login')
def get_by_num(cls, num, key_only=True): if not num: return None if key_only: sql = 'select __key__ from %s where num = :1' % cls.__name__ else: sql = 'select * from %s where num = :1' % cls.__name__ return GqlQuery(sql, num).get()
def fetch2(self, gql, *args, **kwargs): limit = kwargs.get('limit', 100) start_time = time.time() self.keys2 = GqlQuery(gql, *args).fetch(limit) self.seconds2 = time.time() - start_time self.names2 = [key.name() for key in self.keys2] self.gql2 = '%s LIMIT %d' % (replace_args(gql, *args), limit) self.result2 = ' '.join(self.names2)
def get(self, task): task_method_name = 'get_' + task if task_method_name in dir(self) and task_method_name not in dir( super): method = getattr(self, task_method_name) return method() report_log_total = GqlQuery("SELECT __key__ FROM ReportLog").count() report_log_committed = GqlQuery( "SELECT __key__ FROM ReportLog WHERE commit = True").count() self.response.out.write( template.render( 'admin.html', { 'report_log_total': report_log_total, 'report_log_committed': report_log_committed }))
def get(self, email, id=''): if email != '': q = GqlQuery("SELECT * FROM User where email=:emailid", emailid=email) for auser in q.run(limit=1): return auser return None return User.get_by_key_name(id)
def fetch1(self, gql, *args, **kwargs): self.messages = [] limit = kwargs.get('limit', 100) start_time = time.time() self.keys1 = GqlQuery(gql, *args).fetch(limit) self.seconds1 = time.time() - start_time self.names1 = [key.name() for key in self.keys1] self.gql1 = '%s LIMIT %d' % (replace_args(gql, *args), limit) self.result1 = ' '.join(self.names1)
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, name): images = GqlQuery("SELECT * FROM Image WHERE name = :1", name) image = images.get() if image: mime = "jpeg" self.response.headers['Content-Type'] = "image/%s" % mime self.response.out.write(image.thumb) self.response.out.write(image.content) else: self.error(404) self.redirect("/static/nopic.png")
def get(self): #Get the latest count Count.setAllFrontComments(FrontComment.all().count()) Count.setAllSnakeComments(SnakeComment.all().count()) Count.setAllRegisteredUsers(User.all().count()) logged_out = self.request.get('logged_out') logged_in = self.request.get('logged_in') registered = self.request.get('registered') all_comments = self.request.get('allComments') if all_comments == 'True': comments = GqlQuery("SELECT * FROM FrontComment ORDER BY created DESC") else: comments = GqlQuery("SELECT * FROM FrontComment ORDER BY created DESC LIMIT 4") if self.format == 'html': self.render('front.html', frontComments=comments, logged_in=logged_in, logged_out=logged_out, registered=registered) else: return self.render_json([p.as_dict() for p in comments])
def get_room_list(self): q = GqlQuery("SELECT * FROM RoomUser " "WHERE user = :1 ", str(self.key())) result = [] try: for room_user in q: room_key = room_user.room room = Room().get(room_key) room_name = room.key().name() result.append(room_name) finally: return result
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 get(self, username): if self.user: user = Users.byUsername(username) if not user: return self.render('error.html', msg='User Not Found...') userID = str(user.key().id()) posts = GqlQuery('select * from Posts where owner = ' + userID) return self.render('user.html', you=self.user, user=user, posts=posts) else: return self.redirect('/login')
def get(self): users = GqlQuery("SELECT * FROM User") users = list(users) logging.log(40, "Users: " + repr(users)) points = filter(None, (u.coords for u in users)) logging.log(40, "Points: " + repr(points)) img_url = None if points: img_url = gmaps_img(points) self.render('google-maps.html', img_url=img_url, users=users)
def deleteUser(self): htmlHelper.SetContentTypeToXml(self) user = datamodule.GetUser(self.request.get('userName'), self.request.get('password')) if (not user): self.response.out.write( htmlHelper.XmlDeclaration + '<error errorId="4">User not found</error>') return files = GqlQuery('SELECT __key__ FROM Files WHERE user = :1', user) db.delete(files.fetch(1000, 0)) user.delete() self.response.out.write(htmlHelper.XmlDeclaration + '<OK>User Deleted</OK>')
def roomy_list(self): list = [] try: logger = logging.getLogger("canvasLogger") #roomuser has string key for users in it, convert to obj list of users roomyQ = GqlQuery("SELECT * FROM RoomUser WHERE room = :room_key", room_key=str(self.key())) for ru in roomyQ: roomy = User().get(ru.user) list.append(roomy) except: if logger: logger.error("Room.roomy_list: exception") return list
def admin_login(): if request.method == 'POST': id = request.form['username'] pw = request.form['password'] print id, pw q = GqlQuery("SELECT * FROM User WHERE id = :1", id) check_user = q.get() print check_user.password if check_user != None: if check_password(check_user.password, pw): session['username'] = '******' return redirect(url_for('admin_juboam')) return render_template('admin_login.html')
def get(self): image_url = self.request.get('image_url') width = int(self.request.get('width')) name = self.request.get('name') savedimages = GqlQuery( "SELECT * FROM Image WHERE url = :1 and width = :2", image_url, width) image = savedimages.get() if image: image_url = image.url tinyname = image.name else: import random import string image_re = re.compile(r'http://([\w\d\_\=\?\-\.\/\&\;\%]+)') if image_re.search(image_url): domain = image_re.search(image_url).group(0) ext = domain[-3:].lower() if ext == "jpg" or ext == "png" or ext == "gif": mime = ext if ext == "jpg": mime = "jpeg" parts = domain.split("/") filename = parts[len(parts) - 1] #get image image_content = urlfetch.fetch(image_url).content thumb = images.resize(image_content, width, width) tinyname = ''.join(random.sample(string.letters * 2, 10)) if thumb: image = Image() image.url = image_url image.width = width image.name = tinyname image.content = db.Blob(image_content) image.thumb = db.Blob(thumb) image.put() template_values = { 'image_url': image_url, 'width': width, 'name': tinyname } path = os.path.join(os.path.dirname(__file__), 'templates/thumbnails.html') self.response.out.write(template.render(path, template_values))
def index(): user = users.get_current_user() if user: if not UserSettings.has_seen_example() and GqlQuery( 'SELECT __key__ FROM Site WHERE owner=:1 AND example=true', user).count(1) == 0: _create_example_site(user) UserSettings.mark_example_as_seen() sites = Site.gql('WHERE users=:1 ORDER BY name', user) site_form = PageForm() page_form = PageForm() return render_template('index.html', sites=sites, new_site_form=site_form, page_form=page_form) else: return home()
def get(self, table): if table in dir(kloombaDb): i = 0 request = GqlQuery('SELECT * FROM ' + table).run() for item in request: i += 1 if 'timestamp' in dir(item): kloombaDb.__dict__[table].__dict__['timestamp'].__dict__[ 'auto_now'] = False if 'lastActiveTimestamp' in dir(item): kloombaDb.__dict__[table].__dict__[ 'lastActiveTimestamp'].__dict__['auto_now'] = False item.put() memcache.flush_all() self.response.headers['Content-Type'] = 'text/plain' self.response.out.write("Updated table: %s\nUpdated entitys: %d" % (table, i))
def has_write_access(self, user_key): try: if self.owner == user_key: return True if self.public_readwrite: return True if self.group_write: #group_write means you need to be abuddy room_k = str(self.key()) roomyQ = GqlQuery( "SELECT * FROM RoomUser WHERE room = :room_key AND user =:p_user_key ", room_key=room_k, p_user_key=user_key) if roomyQ.get(): return True return False except: return False
def has_read_access(self, user): try: if self.public_read: return True if user == None: return False user_key = str(user.key()) if self.owner == user_key: return True room_k = str(self.key()) roomyQ = GqlQuery( "SELECT * FROM RoomUser WHERE room = :room_key AND user =:p_user_key ", room_key=room_k, p_user_key=user_key) if roomyQ.get(): return True else: return False except: return False