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
