def put(self, guid):
# find the matching user
key = db.Key.from_path('User', int(guid))
user = db.get(key)
if not user == None:
# collect the data from the record
user_json = simplejson.loads(self.request.body)
# The following keeps Guests and Developers and Testers from being able
# to change their role.
currentUserId = self.request.params['UUID']
cukey = db.Key.from_path('User', int(currentUserId))
cuser = db.get(cukey)
if str(user.role) != user_json['role'] and str(cuser.role) != "_Manager":
user_json['role'] = str(user.role)
self.response.set_status(401, "Not Authorized")
# update the record
user = helpers.apply_json_to_model_instance(user, user_json)
# save the record
user.put()
# return the same record...
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(simplejson.dumps(user_json))
else:
self.response.set_status(404, "User not found")
def get(self):
logout = users.create_logout_url(self.request.uri)
user = users.get_current_user()
category_key = self.request.get('id')
pairKey = self.request.get('pair')
showAnswer = self.request.get('show-answer')
error_message = None
category = db.get(category_key)
path = os.path.join(os.path.dirname(__file__), '../templates/category.html')
pair = None
if pairKey:
pair = db.get(pairKey)
else:
pair = category.nextPair
if pair is None:
self.redirect('/view-stats?category=' + str(category.key()))
else:
remaining = category.remaining
answer = pair.answer
if category.reverse:
answer = re.sub(r'\d+\.*', '', answer)
self.response.out.write(template.render(path, {'pair': pair,
'answer': answer,
'reverse': category.reverse,
'category': category,
'remaining': remaining,
'show_answer': showAnswer,
'logout': logout,
}))
def get(self):
id=db.Key(self.request.get('id'))
if not id:
self.redirect('/error?reason=error')
return
allowed= (users.get_current_user() in BlogAdmin)
if not allowed:
self.redirect('/error?reason=forbidden')
return
if not self.request.get('confirm')=='yes':
object_to_remove=""
main=MainPage()
main.isadmin=False
main.call_user=0
object=db.get(id)
if id.kind()=='BlogEntry':
object_to_remove=main.get_entry(object)
elif id.kind()=='BlogComment':
object_to_remove=render_comment(object,main)
values={
'target':object_to_remove,
'id':str(object.key())
}
path = os.path.join(os.path.dirname(__file__), '../../htmls/page_remove.html')
self.response.out.write(template.render(path, values))
else:
self.remove_daughters(id)
db.delete(db.get(id))
self.redirect('/')
def delete(self, guid):
"""Delete the task with the given id"""
if helpers.authorized(self.request.params['UUID'], self.request.params['ATO'], self.request.params['action']):
# search for the Project and delete if found
key = db.Key.from_path('Task', int(guid))
task = db.get(key)
wantsNotifications = {"true": True, "false": False}.get(self.request.params['notify'].lower())
currentUserId = self.request.params['UUID']
cukey = db.Key.from_path('User', int(currentUserId))
user = db.get(cukey)
if not task == None:
# cache current values before updates
taskName = task.name
taskType = task.type
taskPriority = task.priority
taskStatus = task.developmentStatus
taskValidation = task.validation
taskSubmitterId = task.submitterId
taskAssigneeId = task.assigneeId
taskEffort = task.effort
taskProjectId = task.projectId
taskDescription = task.description
# Push notification email on the queue if we need to notify
if notification.should_notify(currentUserId,task,"deleteTask",wantsNotifications):
taskqueue.add(url='/mailer', params={'taskId': int(guid), 'currentUUID': self.request.params['UUID'], 'action': "deleteTask", 'name': taskName, 'type': taskType, 'priority': taskPriority, 'status': taskStatus, 'validation': taskValidation, 'submitterId': taskSubmitterId, 'assigneeId': taskAssigneeId, 'effort': taskEffort, 'projectId': taskProjectId, 'description': taskDescription})
task.delete()
self.response.set_status(204, "Deleted")
else:
self.response.set_status(404, "Not Found")
else:
self.response.set_status(401, "Not Authorized")
def get(self):
aquery = db.Query(College)
mycollege= aquery.get()
username = self.current_user
key = self.request.get('key')
ride = db.get(key)
if ride == None:
doRender(self, 'error.html', {
'error_message': "No such ride exists."})
else:
ride.passengerobjects = []
ride.jsmonth = ride.ToD.month
ride.jsyear = ride.ToD.year
ride.jsday = ride.ToD.day
if ride.start_point_title == mycollege.name:
ride.doOrPu = 0
else:
ride.doOrPu = 1
for p in ride.passengers:
passenger = db.get(p)
if (ride.start_point_lat == passenger.lat and ride.start_point_long == passenger.long) or (ride.destination_lat == passenger.lat and ride.destination_long == passenger.lng):
passenger.samePlace = True;
else:
passenger.samePlace = False;
ride.passengerobjects.append(passenger)
doRender(self, 'rideinfo.html', {
'ride': ride,
'mapkey':MAP_APIKEY
})
def process_article_edit(handler, permalink):
# For http PUT, the parameters are passed in URIencoded string in body
body = handler.request.body
params = cgi.parse_qs(body)
for key,value in params.iteritems():
params[key] = value[0]
property_hash = restful.get_sent_properties(params.get,
['title',
('body', get_sanitizer_func(handler, trusted_source=True)),
('format', get_format),
('updated', get_datetime),
('tags', get_tags),
('html', get_html, 'body', 'format')])
if property_hash:
if 'tags' in property_hash:
property_hash['tag_keys'] = [get_tag_key(name)
for name in property_hash['tags']]
article = db.Query(models.blog.Article).filter('permalink =', permalink).get()
before_tags = set(article.tag_keys)
for key,value in property_hash.iteritems():
setattr(article, key, value)
after_tags = set(article.tag_keys)
for removed_tag in before_tags - after_tags:
db.get(removed_tag).counter.decrement()
for added_tag in after_tags - before_tags:
db.get(added_tag).counter.increment()
process_embedded_code(article)
article.put()
restful.send_successful_response(handler, '/' + article.permalink)
view.invalidate_cache()
else:
handler.error(400)
def process_article_submission(handler, article_type):
property_hash = restful.get_sent_properties(handler.request.get,
['title',
('body', get_sanitizer_func(handler, trusted_source=True)),
'legacy_id',
('format', get_format),
('published', get_datetime),
('updated', get_datetime),
('tags', get_tags),
('html', get_html, 'body', 'format'),
('permalink', permalink_funcs[article_type], 'title', 'published')])
if property_hash:
if 'tags' in property_hash:
property_hash['tag_keys'] = [get_tag_key(name)
for name in property_hash['tags']]
property_hash['format'] = 'html' # For now, convert all to HTML
property_hash['article_type'] = article_type
article = models.blog.Article(**property_hash)
article.set_associated_data(
{'relevant_links': handler.request.get('relevant_links'),
'amazon_items': handler.request.get('amazon_items')})
process_embedded_code(article)
article.put()
for key in article.tag_keys:
db.get(key).counter.increment()
do_sitemap_ping()
restful.send_successful_response(handler, '/' + article.permalink)
view.invalidate_cache()
else:
handler.error(400)
def post(self, post_id):
# code to retrieve selected blog for comment
blogKey = db.Key.from_path('Blog', int(post_id))
SelectedBlog = db.get(blogKey)
# get Userid
currentUser = self.checkCurrentUser()
if currentUser:
# get username and user key
userKey = currentUser.key()
username = currentUser.name
# code to retrieve user input comment
userComment = self.request.get('user_comment')
#Save userComment data in db
savedComment = CommentDB(comment = str(userComment) , blogkey= str(blogKey), userkey= str(userKey), username = str(username))
commentKey = savedComment.put()
# search commented blog based on blog Key in Blog dB
refblog = db.get(blogKey)
refblogCommentCount = refblog.commentCount
if refblogCommentCount:
refblogCommentCount= int(refblogCommentCount) + 1
else:
refblogCommentCount= 1
refblog.commentCount = refblogCommentCount
key = refblog.put()
self.redirect("/blog/%s" % key.id())
self.redirect("/blog/%s" % key.id())
else:
#if user not logged in ask user to Login
self.render('login.html', alert="Please login First.")
def get(self, post_id):
currentUser = self.checkCurrentUser()
if currentUser:
username = currentUser.name
# code to retrieve selected comment for edit
key = db.Key.from_path('CommentDB', int(post_id))
SelectedComment = db.get(key)
commentor = SelectedComment.username
blogKey = SelectedComment.blogkey
selectedBlog = db.get(blogKey)
if username == commentor :
# code to delete comment
db.delete(key)
#Code to update comment count
refblogCommentCount = selectedBlog.commentCount
if refblogCommentCount > 0:
refblogCommentCount= int(refblogCommentCount) - 1
else:
refblogCommentCount= 0
selectedBlog.commentCount = refblogCommentCount
blogKey = selectedBlog.put()
# code to redirect to selected blog
self.redirect("/blog/%s" % blogKey.id())
self.redirect("/blog/%s" % blogKey.id())
else:
self.render("alert.html",currentUser=currentUser.name, message = "Warning! You are not authorized to Delete this comment. Thanks.")
else:
#if user not logged in ask user to Login
self.render('login.html', alert="Please login First.")
def get(self, post_id):
age = memcache.get('age%s' % post_id)
if age is None:
logging.error('AGE INITIALIZED')
age = 0
memcache.set('age%s' % post_id, time.time())
else:
age = int(time.time() - age)
key = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(key)
logged_in = False
username = ''
user_id = self.request.cookies.get('user_id')
if user_id:
logged_in = True
key = db.Key.from_path('User', int(user_id), parent=blog_key())
u = db.get(key)
username = u.username
if not post:
self.error(404)
return
self.render("permalink.html", logged_in = logged_in,
username = username,
post = post,
age = age)
def get(self, post_k):
# Will be returning JSON.
self.response.headers['Content-Type'] = 'application/json'
# Find entry for current user.
user_k = get_user_entity_from_username(
get_current_username(self.request.cookies)).key()
query = db.GqlQuery(
("SELECT * FROM BlogPostReaction "
"WHERE blog_post = :1 AND site_user = :2"),
db.get(post_k),
db.get(user_k))
old_reaction = query.get()
current_value = ""
if old_reaction is not None:
current_value = old_reaction.reaction_type
# Generate data to return and return it.
obj = {'success': True,
'value': current_value}
self.response.out.write(json.dumps(obj))
def post(self):
c_id = self.request.get('id')
# Authentication
if not self.user:
self.redirect('/login')
else:
ckey = db.Key.from_path('Comment', int(c_id), parent=comment_key())
comm = db.get(ckey)
params = dict(id = int(c_id), comment = comm)
# Check if the user is the author of the comment
# Authorization
if self.user.name == comm.author:
#Obtain id from textbox
self.id = self.request.get('id')
ckey = db.Key.from_path('Comment', int(self.id), parent=comment_key())
comm = db.get(ckey)
# Obtain new comment from textarea
self.comm = self.request.get('comment')
#Edit the comment and push it to the datastore
comm.comment = self.comm
comm.put()
self.redirect('/blog/%s' % comm.post)
elif not comm:
self.error(404)
return
else:
self.redirect('/blog/%s' % post.key().id())
def post(self):
c_id = self.request.get('id')
# Authetnication
if not self.user:
self.redirect('/login')
else:
ckey = db.Key.from_path('Comment', int(c_id), parent=comment_key())
comm = db.get(ckey)
params = dict(id = int(c_id), comment = comm)
# Check if user is the author of the comment
# Authorization
if self.user.name == comm.author:
# Obtain id from textbox
self.id = self.request.get('id')
ckey = db.Key.from_path('Comment', int(self.id), parent=comment_key())
comm = db.get(ckey)
pkey = db.Key.from_path('Post', int(comm.post), parent=blog_key())
post = db.get(pkey)
#Delete comment and decrement from datastore
comm.delete()
post.comments = post.comments - 1
post.put()
self.redirect('/blog/%s' % post.key().id())
elif not comm:
self.error(404)
return
else:
self.redirect('/blog/%s' % post.key().id())
def append_websites (document, person_element, faculty):
website_query = db.get(faculty.websites)
#website_query = db.GqlQuery("SELECT * FROM Website WHERE person = :this_person", this_person=faculty.key())
for website in website_query:
# main tag
website_element = document.createElement('website')
person_element.appendChild(website_element)
#one url, one group, one or more author
append_text_node(document, website_element, 'url', website.address)
append_text_node(document, website_element, 'group', website.group.name)
for author in website.authors:
author_element = document.createElement('author')
website_element.appendChild(author_element)
append_text_node(document, author_element, 'first_name', db.get(author).first)
append_text_node(document, author_element, 'last_name', db.get(author).last)
middle = db.get(author).middle
if middle is not None:
append_text_node(document, author_element, 'middle_name', middle)
suffix = db.get(author).suffix
if suffix is not None:
append_text_node(document, author_element, 'suffix', suffix)
def post(self):
post_id = self.request.get('id')
# Authentication
if not self.user:
self.redirect('/login')
else:
pkey = db.Key.from_path('Post', int(post_id), parent=blog_key())
post = db.get(pkey)
# Check if the user is the author of the post
# Authorization
if self.user.name != post.author:
self.redirect('/blog/%s' % post_id)
else:
# Obtain id from the textbox
self.id = self.request.get('id')
pkey = db.Key.from_path('Post', int(self.id), parent=blog_key())
post = db.get(pkey)
# Get subject and content
self.subject = self.request.get('subject')
self.content = self.request.get('content')
params = dict(subject = self.subject, content = self.content, id = self.id)
# Sets the subject the content and pushes the edited post to the datastore
post.subject = self.subject
post.content = self.content
post.put()
self.redirect('/blog/%s' %self.id)
def get(self, one_num):
if 'Referer' in self.request.headers:
go = self.request.headers['Referer']
else:
go = '/'
member = CheckAuth(self)
t = self.request.get('t')
if member:
if str(member.created_ts) == str(t):
one = GetKindByNum('Member', int(one_num))
if one is not False:
if one.num != member.num:
q = db.GqlQuery("SELECT * FROM MemberBookmark WHERE one = :1 AND member_num = :2", one, member.num)
if q.count() > 0:
bookmark = q[0]
bookmark.delete()
member = db.get(member.key())
member.favorited_members = member.favorited_members - 1
member.put()
memcache.set('Member_' + str(member.num), member, 86400)
n = 'r/m' + str(one.num) + '/m' + str(member.num)
memcache.delete(n)
one = db.get(one.key())
one.followers_count = one.followers_count - 1
one.put()
memcache.set('Member_' + str(one.num), one, 86400)
memcache.set('Member::' + str(one.username_lower), one, 86400)
self.redirect(go)
def post(self):
import time
date = time.strftime('%Y-%m-%d', time.gmtime())
k = db.Key(self.request.get('clientkey'))
invoice = Invoices()
invoice.client = k
invoice.date = date
invoice.status = 'draft'
invoice.total = 0.00
invoice.put()
iid = invoice.key()
invoiceid = str(invoice.inum)
billedtotal = 0.00
billedtime = 0.00
# there is a form that lists the projects, allowing the user to
# check one or more the field data is the key for that project
# get_all gives an array of keys returned which we want to pull
# time from
projects = self.request.get_all('projects')
# start looping through the keys
for projectkey in projects:
# make the string key an actual key object
pkey = db.Key(projectkey)
# get everything out of the time store with that project
# associated and which has a status of logged.
times_query = Time.all()
times_query.filter('project =', pkey)
times_query.filter('status =', 'logged')
times = times_query.fetch(100)
for time in times:
time.invoice = iid
time.status = "invoiced"
db.put(time)
billedtime = float(billedtime) + float(time.hours)
billedtotal = float(billedtotal) + float(time.total)
project_update = db.get(pkey)
project_update.status = "empty"
project_update.put()
totalhoursbilled = "%2.f" % billedtime
totalbill = "%.2f" % billedtotal
totalbill = float(totalbill)
invoice_update = db.get(iid)
invoice_update.totalhours = float(totalhoursbilled)
invoice_update.totalbill = totalbill
invoice_update.put()
project_update = db.get(pkey)
project_update.billed = billedtime
project_update.put()
action = '/invoice?iid=' + str(iid)
self.redirect(action)
def get(self, mode, id):
articles = models.Article.all()
def mode_mapper(m):
if m=='page':
return 'slug'
elif m=='tag':
return 'tags'
else:
return m
articles.filter("%s =" % mode_mapper(mode), id)
article = articles.fetch(1)
for art in article:
rimages = []
rheights = []
for image in art.images:
rimages.append(db.get(image))
img = images.Image(blob_key=str(db.get(image).file.key()))
img.im_feeling_lucky()
img.execute_transforms(output_encoding=images.JPEG,quality=1)
rheights.append(float(img.height) / float(img.width))
art.rimages = rimages
articles = models.Article.all().order('-pubdate').fetch(20)
for sarticle in articles:
sarticle.rimages = [db.get(image) for image in sarticle.images]
self.generate('page.html',
template_values = {
'articles' : articles,
'article' : article,
'rheights' : rheights,
'%sid' % mode: id,
})
def put(self, key):
'''Adds a Character to a Party.
'''
_trace = TRACE+'APIParties:: put() '
logging.info(_trace)
_party = db.get(key)
if _party is not None and _party.class_name() == 'Party':
try:
character_key = self.request.get('character_key')
except AttributeError:
r = API400
r[MSG] = 'Missing \'character_key\' parameter.'
character = db.get(character_key)
if character is not None and character.class_name() == 'Character':
_party = party.updateJSONParty(party, character)
r = API200
r[MSG] = 'The party grows stronger!'
r[_party.class_name()] = _party
else:
r = API404
r[MSG] = 'Character not found for key '+character_key+' .'
r = API200
r[MSG] = 'Adventure a party makes.'
r[_party.class_name()] = party.getJSONParty(party)
else:
r = API404
r[MSG] = 'Party not found for key '+key+' .'
return self.response.out.write(simplejson.dumps(r))
def post(self):
group_k = self.request.get("key")
group = db.get(group_k)
member_k = db.Key.from_path('Person', self.request.get('email'))
member = db.get(member_k)
if member == None:
response = {
"success": False,
"error": "No such user found"
}
elif self.request.get('action') == "add":
if group.key() not in member.groups:
member.groups.append(group.key())
member.put()
response = {
"success": True,
"member": member.name
}
else:
response = {
"success": False,
"error": "User is already in group"
}
elif self.request.get('action') == "remove":
member.groups.remove(group.key())
member.put()
response = {"success": True}
self.response.content_type = 'application/json'
self.response.write(json.dumps(response))
def assertEqualTree(self, tree, parent='0', ancestors=[u'root'], cls=Menu):
pos = 0
expected_sibs = [unicode(k[0]) for k in tree]
for k in tree:
node = find_node(k[0],cls)
# path
self.assertEqual(node.path,u'%s%s%s' % (parent, u'.', pos))
# siblings
node_sibs = [db.get(n).name for n in node.siblings]
node_sibs.sort()
expected_sibs.remove(k[0])
expected_sibs.sort()
self.assertEqual(expected_sibs, node_sibs)
expected_sibs.append(k[0])
# ancestors
node_ancestors = [db.get(n).name for n in node.ancestors]
self.assertEqual(ancestors, node_ancestors)
if len(k) > 1:
# children
expected_children = [unicode(l[0]) for l in k[1]]
expected_children.sort()
node_children = [db.get(n).name for n in node.children]
node_children.sort()
self.assertEqual(expected_children, node_children)
# recurse
self.assertEqualTree(k[1], u'%s%s%s' % (parent, u'.', pos), ancestors+[node.name])
pos += 1
def get_user(user=None, user_id=None):
'''Get a user from the DataStore using a User object or a user ID'''
id = user.user_id() if user else user_id
if id == 'us':
return False
else:
e = mget(key=id, namespace='profile_data')
if e is None:
try:
q = User.all().filter('id', id).fetch(1)
e = q[0]
except:
u = User(
id=id,
user=user,
nickname=user.nickname(),
)
e = db.get(u.put())
if e.bio is None or e.shared is None:
if e.bio is None:
m = User_Bio().put()
e.bio = m
if e.shared is None:
p = User_Permissions().put()
e.shared = p
e = db.get(db.put(e))
mset(key=id, value=e, time=10, namespace='profile_data')
return e
def test_put_expiry_flags(self):
# Try put_expiry_flags when the record has not expired yet.
assert not self.p1.is_expired
self.p1.put_expiry_flags()
# Both entities should be unexpired.
p1 = db.get(self.p1.key())
assert p1.expiry_date
assert not p1.is_expired
assert p1.given_name == 'John'
n1_1 = db.get(self.n1_1.key())
assert not n1_1.is_expired
# Advance past the expiry date and try again.
set_utcnow_for_test(datetime(2010, 2, 3))
p1.put_expiry_flags()
# Both entities should be expired.
p1 = db.get(self.p1.key())
assert p1.is_expired
assert p1.given_name == 'John'
assert p1.source_date == datetime(2010, 2, 3)
assert p1.entry_date == datetime(2010, 2, 3)
assert p1.expiry_date == datetime(2010, 2, 1)
n1_1 = db.get(self.n1_1.key())
assert n1_1.is_expired
def post(self):
question = db.get(self.request.get('question'))
quiz = db.get(self.request.get('quiz'))
# cannot copy a question into another user's quiz
if quiz.owner == users.get_current_user():
question.copyto(quiz)
self.redirect('/questions?quiz=%s' % (quiz.key(),))
def post(self):
quiz = db.get(self.request.get('quiz'))
category = db.get(self.request.get('category'))
if quiz.owner == users.get_current_user() or users.is_current_user_admin():
quiz.category = category
quiz.put()
self.redirect('/')
def get(self):
bbs = db.get(self.request.get("bbs_key"))
user = users.get_current_user()
entry = db.get(self.request.get("entry_key"))
entry_owner=False
if(user and user.user_id()==entry.user_id):
entry_owner=True
bbs_owner=not OwnerCheck.check(bbs,user)
if(not bbs_owner and not OwnerCheck.is_admin(user) and not entry_owner):
self.response.out.write(Alert.alert_msg("削除する権限がありません。",self.request.host))
return
entry.del_flag = 0
entry.put()
thread = db.get(self.request.get("thread_key"))
thread.comment_cnt=thread.comment_cnt-1
thread.cached_entry_key=[]
thread.cached_entry_key_enable=None
thread.put()
url=MappingThreadId.get_thread_url("./",bbs,thread)+"?comment_edit=1"
self.redirect(str(url))
RecentCommentCache.invalidate(bbs)
def _un_subscribe(self, app_user, si_user, broadcast_type):
user_profile, si, fsic = db.get([UserProfile.createKey(app_user),
ServiceIdentity.keyFromUser(add_slash_default(si_user)),
FriendServiceIdentityConnection.createKey(app_user, si_user)])
logging.info('%s is unsubscribing from notifications of "%s" with type "%s".',
user_profile.name if user_profile else app_user.email(),
si.name if si else si_user.email(),
broadcast_type)
updated = False
if fsic:
if broadcast_type in fsic.enabled_broadcast_types:
fsic.enabled_broadcast_types.remove(broadcast_type)
updated = True
if broadcast_type not in fsic.disabled_broadcast_types:
fsic.disabled_broadcast_types.append(broadcast_type)
updated = True
if updated:
fsic.put()
models = db.get([UserData.createKey(fsic.friend, fsic.service_identity_user)] +
[get_mobile_key_by_account(mobile.account) for mobile in user_profile.mobiles])
user_data_model, mobiles = models[0], models[1:]
create_send_user_data_requests(mobiles, user_data_model, fsic, fsic.friend, fsic.service_identity_user)
schedule_update_a_friend_of_a_service_identity_user(fsic.service_identity_user, fsic.friend, force=True,
clear_broadcast_settings_cache=True)
else:
logging.info('%s was already unsubscribed from notifications of "%s" with type "%s".',
user_profile.name if user_profile else app_user.email(),
si.name if si else si_user.email(),
broadcast_type)
return updated, user_profile, si, fsic
def post(self):
loser = db.get(str(self.request.get('loser')))
winner = db.get(str(self.request.get('winner')))
vote = Vote(winner=winner, loser=loser)
#To store username if the user is logged in
client = OAuthClient("twitter", self)
logged_in = client.get_cookie()
if logged_in:
info = client.get("/account/verify_credentials")
vote.name = info["screen_name"]
else:
vote.name = 'Guest'
#TODO: Stop spam-voting for same key from same ip repeatedly
vote.ip = self.request.remote_addr
if check_vote_spam(vote.ip, winner):
self.redirect('/msg=You+appear+to+be+votespamming,+please+stop+or+try+again+later')
else:
vote.put()
#Wins and losses
loser.losses = loser.losses+1
loser.win_percentage = loser.calc_win_percentage()
loser.put()
winner.wins = winner.wins+1
winner.win_percentage = winner.calc_win_percentage()
winner.put()
#Redirect so that people cannot repost twice
self.redirect('/?w=%s&l=%s' % (winner.key().id(), loser.key().id()))
def getall(self,catname=None,tagname=None):
data=[]
if catname:
catkey=[categoryobj.key() for categoryobj in self.categories if categoryobj.category==catname][0]
posts=[]
[posts.append(post) for post in self.posts if catkey ==post.category.key()]
#logging.info([catkey,len(categories)])
elif tagname:
logging.info(tagname)
tagkey=[tagobj.key() for tagobj in self.tags if tagobj.tag==tagname]
if tagkey:tagkey=tagkey[0]
posts=[]
[posts.append(post) for post in self.posts if tagkey in post.tags]
else:posts=self.posts
for post in posts:
tags=[]
[tags.append({"tag":db.get(key).tag,"tagid":db.get(key).key().id()}) for key in post.tags]
updated=str(post.updated.day)+" "+str(months[post.updated.month])+" "+str(post.updated.year)
dateposted=str(post.timestamp.day)+" "+str(months[post.timestamp.month])+" "+str(post.timestamp.year)
data.append({"title":post.title,"body":post.body,"category":db.get(post.category.key()).category,
"catid": db.get(post.category.key()).key().id(),"id":str(post.key().id()),\
"tags":tags,"date":dateposted,"updated":updated})
return(data)
def post(self):
group_k = self.request.get("key")
if group_k == "":
parent_key = db.Key.from_path('Person', users.get_current_user().email())
group = Group(parent=parent_key)
group.name = self.request.get('groupname')
group.put()
group_k = group.key()
person = db.get(parent_key)
person.groups.append(group_k)
person.put()
response = {
"success": True,
"key": str(group.key()),
"email": parent_key.name(),
"name": person.name
}
else:
group = db.get(group_k)
for member in group.members:
member.groups.remove(group.key())
member.put()
db.delete(group_k)
response = {"success": True}
self.response.content_type = 'application/json'
self.response.write(json.dumps(response))
def isFileExists(self, fileName):
key = db.Key.from_path('FileInfo', fileName)
file_info = db.get(key)
return file_info
def do_update():
e = db.get(key)
if self.update(e):
e.put()
if datetime.datetime.now() > deadline:
raise DeadlineExceededError
def by_id(cls, id):
key = db.Key.from_path('Comment', int(id))
comment = db.get(key)
if comment:
return comment
def by_id(cls, id):
key = db.Key.from_path('Post', int(id), parent=blog_key())
post = db.get(key)
if post:
return post
def increment_counter(key): obj = db.get(key) obj.counter += 1 obj.put() return obj.counter
def post(self):
LoggedIn = False
User = Team = ""
path = os.environ['PATH_INFO']
if (self.session.get('user')): # (NEWSESSION)
LoggedIn = True
User = self.session['fname'] + " " + self.session['lname']
Team = " (" + self.session['team'] + ")"
if (LoggedIn == False):
self.Writeln("<p><br><p><br>")
self.Writeln("<body bgcolor=d2d2ff>")
self.Writeln("<center>")
self.Writeln("<h1>Please Login </h1>")
self.Writeln("</center>")
return
courts = self.request.get('courts')
if (courts == ""):
self.Writeln("<p><br><p><br>")
self.Writeln("<body bgcolor=d2d2ff>")
self.Writeln("<center>")
self.Writeln("<h1>Please Select Courts </h1>")
self.Writeln("</center>")
return
e = db.get(courts)
# This shouldn't ever happen since reserved court can't be selected
if (type(e.owner) is not types.NoneType):
self.Writeln("<p><br><p><br>")
self.Writeln("<body bgcolor=d2d2ff>")
self.Writeln("<center>")
self.Writeln("<h1>Courts already Selected </h1>")
self.Writeln("</center>")
return
# -------------------------------------------------------------------
# By now, use has logged in and selected courts
# (NEWSESSION)
captain_keyname = self.session['keyname']
Captain = datastore.Captain.get_by_key_name(captain_keyname)
CourtTime = ""
g = datastore.OpenDate.get_by_key_name("key_opendate")
if (g == None):
self.Writeln("<p><br><p><br>")
self.Writeln("<center>")
self.Writeln("<body bgcolor=d2d2ff>")
self.Writeln("WARNING! Set Opening Date For Reservations")
return
start = g.openingdate
StartDate = library.getDate(g.openingdate)
StartTime = library.ctime(g.openingdate)
Today = library.getDate(datetime.datetime.utcnow() -
datetime.timedelta(hours=8))
Today = Today + " @" + library.ctime(datetime.datetime.utcnow() -
datetime.timedelta(hours=7))
delta = datetime.datetime.utcnow() - datetime.timedelta(
hours=8) - start
if (datetime.datetime.utcnow() - datetime.timedelta(hours=8) < start):
self.Writeln("<p><br><p><br>")
self.Writeln("<center>")
self.Writeln("<body bgcolor=d2d2ff>")
self.Writeln("<h1>Can't Reserve yet </h1>")
self.Writeln("<h1>Today is " + Today + "</h1>")
self.Writeln("<h1>Reservations start " + StartDate + "@" +
StartTime + "</h1>")
self.Writeln("</center>")
return
Allowed = 2 + 2 * delta.days
sofar = Captain.count
if (sofar >= Allowed):
Exceeded = True
template_values = {
'Host': library.Host(),
'StartDate': StartDate,
'StartTime': StartTime,
'Today': Today,
'Allowed': Allowed,
'Captain': Captain,
'Exceeded': True
}
path = os.path.join(os.path.dirname(__file__),
'display_request.html')
self.response.out.write(template.render(path, template_values))
return
# ----------------------------------------------------------------------------------
# Reserve the courts
# courts is the Key to the court selected
courts = cgi.escape(self.request.get('courts'))
e = db.get(courts)
CourtDate = library.getDate(e.date)
CourtDay = e.weekday
CourtStart = library.ctime(e.start)
CourtEnd = library.ctime(e.end)
Courts = library.listconv(e.courts)
CourtDesc = e.desc
Month = e.date.month
Year = e.date.year
e.owner = captain_keyname # either use session value or from Captain db
db.put(e)
Captain.count = Captain.count + 1
db.put(Captain)
template_values = {
'Host': library.Host(),
'Month': Month,
'Year': Year,
'StartDate': StartDate,
'StartTime': StartTime,
'Today': Today,
'Allowed': Allowed,
'Captain': Captain,
'CourtDate': CourtDate,
'CourtDay': CourtDay,
'CourtStart': CourtStart,
'CourtEnd': CourtEnd,
'Courts': Courts,
# 'CourtDesc' : CourtEnd,
'Exceeded': False
}
path = os.path.join(os.path.dirname(__file__), 'templates',
'reserve.html')
self.response.out.write(template.render(path, template_values))
xml_content = forms["xml"].value
xml_hash = hash(xml_content)
lookup_query = db.Query(Xml)
lookup_query.filter("xml_hash =", xml_hash)
lookup_result = lookup_query.get()
if lookup_result:
xml_key = lookup_result.key().name()
else:
trials = 0
result = True
while result:
trials += 1
if trials == 100:
raise Exception("Sorry, the generator failed to get a key for you.")
xml_key = keyGen()
result = db.get(db.Key.from_path("Xml", xml_key))
xml = db.Text(xml_content, encoding="utf_8")
row = Xml(key_name = xml_key, xml_hash = xml_hash, xml_content = xml)
row.put()
print xml_key
if "key" in forms:
# Retrieve stored XML based on the provided key.
key_provided = forms["key"].value
# Normalize the string.
key_provided = key_provided.lower().strip()
# Check memcache for a quick match.
xml = memcache.get("XML_" + key_provided)
if xml is None:
# Check datastore for a definitive match.
result = db.get(db.Key.from_path("Xml", key_provided))
def get(self):
self.session = Session()
userkey=self.session['userkey']
user=db.get(userkey)
doRender(self, 'changeDetails.html', {'name' : user.name, 'surname' : user.surname})
def get(self):
"""Get handler for comparing test suites."""
# Let's preprocess all request parameters.
params = self.ProcessRequestParams()
suite_key = params['suite_key']
if not suite_key:
self.response.out.write('No suite key specified.')
return
if suite_key.lower() == 'latest':
suite = test_suite.TestSuite.all().order('-date')[0]
else:
suite = db.get(db.Key(suite_key))
if not suite:
self.response.out.write('No Matching suites found.')
return
processed_results = self.FetchAndProcessPageDelta(params, suite)
delta_count = suite.results.count()
data_count = suite.page_data_set.count()
# Let's create URLs/links for template.
start = params['offset']
end = min(params['offset'] + params['limit'] - 1, delta_count)
next_ = params['offset'] + params['limit']
if next_ >= delta_count:
next_ = ''
else:
next_ = str(next_)
prev = params['offset'] - params['limit']
if prev < 0:
prev = ''
else:
prev = str(prev)
prev_url = self.InsertQueryParams(params['url'], {'offset': prev})
next_url = self.InsertQueryParams(params['url'], {'offset': next_})
latest_url = self.InsertQueryParams(params['url'], {'order': '-date'})
scores_hl_url = self.InsertQueryParams(params['url'],
{'order': '-score'})
scores_lh_url = self.InsertQueryParams(params['url'],
{'order': 'score'})
template_values = {
'data_count': data_count,
'delta_count': delta_count,
'deltas': processed_results['deltas'],
'end': end,
'latest_url': latest_url,
'limit': params['limit'],
'next': next_,
'next_url': next_url,
'prev': prev,
'prev_url': prev_url,
'record_count': processed_results['record_count'],
'scores_hl_url': scores_hl_url,
'scores_lh_url': scores_lh_url,
'start': start,
'suite': suite,
'url': params['url']
}
if params['display_stripdown'] and params[
'display_stripdown'] == 'true':
self.RenderTemplate('suite_compare_stripdown.html',
template_values)
return
else:
self.RenderTemplate('suite_compare.html', template_values)
return
def post(self, blog_id):
# get all the necessary parameters
key = db.Key.from_path("Blog", int(blog_id), parent=blog_key())
post = db.get(key)
user_id = User.by_name(self.user.name)
comments_count = Comment.count_by_blog_id(post)
post_comments = Comment.all_by_blog_id(post)
likes = Like.by_blog_id(post)
unlikes = Unlike.by_blog_id(post)
previously_liked = Like.check_like(post, user_id)
previously_unliked = Unlike.check_unlike(post, user_id)
# check if the user is logged in
if self.user:
# if the user clicks on like
if self.request.get("like"):
# check if the user try like his own post
if post.user.key().id() != User.by_name(
self.user.name).key().id():
if previously_liked == 0:
# add like to the likes database and refresh the page
l = Like(post=post, user=User.by_name(self.user.name))
l.put()
time.sleep(0.1)
self.redirect('/post/%s' % str(post.key().id()))
# otherwise if the user has liked this post before throw
# and error
else:
error = "You have already liked this post"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
error=error,
comments_count=comments_count,
post_comments=post_comments)
# otherwise if the user is trying to like his own post throw an
# error
else:
error = "You cannot like your own posts"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
error=error,
comments_count=comments_count,
post_comments=post_comments)
# if the user clicks on unlike
if self.request.get("unlike"):
# first check if the user is trying to unlike his own post
if post.user.key().id() != User.by_name(
self.user.name).key().id():
# then check if the user has unliked this post before
if previously_unliked == 0:
# add unlike to the unlikes database and refresh the
# page
ul = Unlike(post=post,
user=User.by_name(self.user.name))
ul.put()
time.sleep(0.1)
self.redirect('/post/%s' % str(post.key().id()))
# otherwise if the user has unliked this post before throw
# and error
else:
error = "You have already unliked this post"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
error=error,
comments_count=comments_count,
post_comments=post_comments)
# otherwise if the user is trying to unlike his own post throw
# an error
else:
error = "You cannot unlike your own posts"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
error=error,
comments_count=comments_count,
post_comments=post_comments)
# if the user clicks on add comment get the comment text first
if self.request.get("add_comment"):
comment_text = self.request.get("comment_text")
# check if there is anything entered in the comment text area
if comment_text:
# add comment to the comments database and refresh page
c = Comment(post=post,
user=User.by_name(self.user.name),
text=comment_text)
c.put()
time.sleep(0.1)
self.redirect('/post/%s' % str(post.key().id()))
# otherwise if nothing has been entered in the text area throw
# an error
else:
comment_error = "Please enter a comment in the text area"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
comments_count=comments_count,
post_comments=post_comments,
comment_error=comment_error)
# if the user clicks on edit post
if self.request.get("edit"):
# check if the user is the author of this post
if post.user.key().id() == User.by_name(
self.user.name).key().id():
# take the user to edit post page
self.redirect('/edit/%s' % str(post.key().id()))
# otherwise if the user is not the author of this post throw an
# error
else:
error = "You cannot edit other user's posts"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
comments_count=comments_count,
post_comments=post_comments,
error=error)
# if the user clicks on delete
if self.request.get("delete"):
# check if the user is the author of this post
if post.user.key().id() == User.by_name(
self.user.name).key().id():
# delete the post and redirect to the main page
db.delete(key)
time.sleep(0.1)
self.redirect('/')
# otherwise if the user is not the author of this post throw an
# error
else:
error = "You cannot delete other user's posts"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
comments_count=comments_count,
post_comments=post_comments,
error=error)
# otherwise if the user is not logged in take them to the login page
else:
self.redirect("/login")
def get(self):
"""
Called when adding a passenger to a ride
Arguments:
- 'self'
Web Arguments:
- user_name
- ride_key
"""
# The current user can add himself to the ride. No need for this in the form.
user_name = self.current_user.id
ride_key = self.request.get('ride_key')
contact = self.request.get('contact')
address = self.request.get('address')
lat = float(self.request.get('lat'))
lng = float(self.request.get('lng'))
ride = db.get(db.Key(ride_key))
if ride == None: # Check if the ride was found
temp = os.path.join(os.path.dirname(__file__),
'templates/error.html')
outstr = template.render(
temp, {'error_message': 'Error in ride matching'})
self.response.out.write(outstr)
# Check if the current user is the driver
elif ride.max_passengers == ride.num_passengers:
doRender(self, 'error.html',
{'error_message': 'This ride is full'})
# Check if the current user is already on the ride
already = False
for p in ride.passengers:
if db.get(p).name == user_name:
already = True
if already:
temp = os.path.join(os.path.dirname(__file__),
'templates/error.html')
outstr = template.render(
temp,
{'error_message': 'You are already registered for this ride!'})
self.response.out.write(outstr)
# Check if the current user is already the driver for the ride
elif user_name == ride.driver:
doRender(
self, 'error.html', {
'error_message':
'You can\'t be a passenger for a ride which you a driving.'
})
else:
passenger = Passenger()
passenger.name = user_name
passenger.fullname = FBUser.get_by_key_name(user_name).nickname()
passenger.contact = contact
passenger.location = address
passenger.lat = lat
passenger.lng = lng
passenger.ride = db.Key(ride_key)
pass_key = passenger.put()
ride.num_passengers = ride.num_passengers + 1
ride.passengers.append(pass_key)
ride.put()
if ride.num_passengers == ride.max_passengers:
capacity_message = 'is now full.'
else:
num_left = ride.max_passengers - ride.num_passengers
capacity_message = 'can hold ' + str(
num_left) + ' more passengers.'
query = db.Query(Ride)
query.filter("ToD > ", datetime.datetime.now())
ride_list = query.fetch(limit=100)
user = self.current_user
greeting = ''
if user:
greeting = (
"Welcome, %s! (<a href=\"%s\">sign out</a>) Go to your <a href='/home'>Home Page</a>"
% (user.nickname(), users.create_logout_url("/")))
message = 'You have been added to %s ride.' % (ride.driver)
self.sendDriverEmail(ride)
path = os.path.join(os.path.dirname(__file__),
'templates/index.html')
self.response.out.write(
template.render(
path, {
'ride_list': ride_list,
'greeting': greeting,
'message': message,
'mapkey': MAP_APIKEY,
}))
def get(self):
"""Get handler for test suite details page."""
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
suite_key = self.request.get('suite')
if not suite_key:
self.response.out.write('No suite key specified.')
return
if suite_key.lower() == 'latest':
suite = test_suite.TestSuite.all().order('-date')[0]
else:
suite = db.get(db.Key(suite_key))
if not suite:
self.response.out.write('No Matching suites found.')
return
offset = int(
self.GetOptionalParameter(parameter_name='offset',
default_value=0))
# Limit is used for pagination. Indicates number of entities/records
# to display on a single page.
limit = int(
self.GetOptionalParameter(parameter_name='limit',
default_value=20))
order = self.GetOptionalParameter(parameter_name='order',
default_value='-date')
deltas = suite.results.order(order).fetch(limit=limit, offset=offset)
delta_count = suite.results.count()
data_count = suite.page_data_set.count()
start = offset
end = min(offset + limit - 1, delta_count)
next_ = offset + limit
if next_ >= delta_count:
next_ = ''
else:
next_ = '%d' % next_
prev = offset - limit
if prev < 0:
prev = ''
else:
prev = '%d' % prev
ref_browser = suite.ref_browser.GetBrowserStringWithFlag()
test_browsers = suite.GetTestBrowsersStringWithFlag()
template_values = {
'data_count': data_count,
'deltas': deltas,
'delta_count': delta_count,
'end': end,
'is_admin': users.is_current_user_admin(),
'limit': limit,
'next': next_,
'order': order,
'prerendered_string': page_delta.PRERENDERED_STRING,
'prev': prev,
'ref_browser': ref_browser,
'start': start,
'suite': suite,
'test_browsers': test_browsers,
'url': '/suite/details?suite=%s' % suite_key
}
self.RenderTemplate('suite_details.html', template_values)
return
def __Dynamic_Read(self, request, response):
"""Implements _Dynamic_Read if called by _run_in_namespace."""
response.clear_offset()
if request.version_id_size() != 1:
raise apiproxy_errors.ApplicationError(
log_service_pb.LogServiceError.INVALID_REQUEST)
if (request.request_id_size()
and (request.has_start_time() or request.has_end_time()
or request.has_offset())):
raise apiproxy_errors.ApplicationError(
log_service_pb.LogServiceError.INVALID_REQUEST)
if request.request_id_size():
results = []
try:
results = db.get(request.request_id_list())
except datastore_errors.BadKeyError:
for request_id in request.request_id_list():
try:
results.append(db.get(request_id))
except datastore_errors.BadKeyError:
pass
for result in results:
if result.version_id != request.version_id(0):
continue
log = response.add_log()
app_logs = db.get(result.app_logs)
result.fill_in_log(request, log, app_logs)
return
query = db.Query(_LogRecord)
if request.has_offset():
query.filter('__key__ > ', db.Key(request.offset().request_id()))
if request.has_count():
limit = request.count()
else:
limit = LogServiceStub.__DEFAULT_READ_COUNT
versions = request.version_id_list()
index = 0
for result in query.run(limit=limit):
index += 1
start = result.start_time
if request.has_start_time():
if request.start_time() > start:
continue
if request.has_end_time():
if request.end_time() <= start:
continue
if not request.include_incomplete() and not result.finished:
continue
if result.version_id not in versions:
continue
app_logs = db.get(result.app_logs)
if request.has_minimum_log_level():
for app_log in app_logs:
if app_log.level >= request.minimum_log_level():
break
else:
continue
log = response.add_log()
result.fill_in_log(request, log, app_logs)
log.mutable_offset().set_request_id(str(result.key()))
if index == limit:
response.mutable_offset().set_request_id(str(result.key()))
def get_blogpost(self, post_id):
key = db.Key.from_path('Blogpost', int(post_id))
blogpost = db.get(key)
return blogpost
def latest_comments(limit):
comments = Comment.all().order('-time').fetch(limit)
articles = db.get([comment.parent_key() for comment in comments])
users = db.get(
[db.Key.from_path('User', comment.email) for comment in comments])
return comments, articles, users
from google.appengine.ext import db
import scarlett.model as model
def printEntity(entity):
print "%s = %s, %i" % (entity.key().name(), entity.level, entity.value)
totalKey = db.Key.from_path("Matrix", "KEY/----------/T/-/a")
totalEntity = db.get(totalKey)
printEntity(totalEntity)
query = model.Matrix.gql(
"where level = :level and ancestor is :parent",
level=u"Y",
parent=totalKey)
for yearEntity in query:
printEntity(yearEntity)
print "totalViewer!"
def retrieve(self,key):
cd = db.get(db.Key.from_path('Cache', key))
return cd.value.decode('utf-8') if cd else None
def _broadcast(sln_settings_key, sandwich_settings_key):
sln_settings, sandwich_settings = db.get(
[sln_settings_key, sandwich_settings_key])
if not sln_settings:
logging.info("Service has been deleted in the meantime")
return
solution_datetime = datetime.now(pytz.timezone(sln_settings.timezone))
if not sandwich_settings.can_order_sandwiches_on(solution_datetime):
logging.info("No email_reminders anymore today for %s",
sln_settings.service_user.email())
return
broadcast_type = get_sandwich_reminder_broadcast_type(
sln_settings.main_language or DEFAULT_LANGUAGE,
SandwichSettings.DAYS[solution_datetime.weekday()])
message = sandwich_settings.reminder_broadcast_message
order_sandwich_answer = AnswerTO()
order_sandwich_answer.action = None
order_sandwich_answer.caption = translate(sln_settings.main_language,
SOLUTION_COMMON, u'order')
order_sandwich_answer.type = u'button'
order_sandwich_answer.id = u'order'
order_sandwich_answer.ui_flags = 1
no_sandwich_today_answer = AnswerTO()
no_sandwich_today_answer.action = None
no_sandwich_today_answer.caption = translate(
sln_settings.main_language, SOLUTION_COMMON,
u'order-sandwiches-not-today')
no_sandwich_today_answer.type = u'button'
no_sandwich_today_answer.id = u'Not now'
no_sandwich_today_answer.ui_flags = 0
answers = list()
answers.append(order_sandwich_answer)
answers.append(no_sandwich_today_answer)
flags = 0
branding = db.get(
SolutionMainBranding.create_key(
sln_settings.service_user)).branding_key
tag = MESSAGE_TAG_SANDWICH_ORDER_NOW
alert_flags = 0
timeout = sandwich_settings.get_reminder_broadcast_timeout(
solution_datetime)
users.set_user(sln_settings.service_user)
try:
identities = [None]
if sln_settings.identities:
identities.extend(sln_settings.identities)
for service_identity in identities:
sln_i_settings = get_solution_settings_or_identity_settings(
sln_settings, service_identity)
if sln_i_settings.is_in_holiday_for_date(now()):
logging.info(
"Not sending out sandwich broadcast '%s'. %s is in holiday.",
broadcast_type, sln_i_settings.service_user)
else:
logging.info(
"Sending broadcast to users of %s with broadcast type %s",
sln_i_settings.service_user, broadcast_type)
messaging.broadcast(broadcast_type,
message,
answers,
flags,
branding,
tag,
service_identity,
alert_flags,
timeout=timeout)
finally:
users.clear_user()
def handle(self):
"""Handle request."""
tstate = model.TransientShardState.from_request(self.request)
spec = tstate.mapreduce_spec
self._start_time = self._time()
shard_id = tstate.shard_id
shard_state, control = db.get([
model.ShardState.get_key_by_shard_id(shard_id),
model.MapreduceControl.get_key_by_job_id(spec.mapreduce_id),
])
if not shard_state:
# We're letting this task to die. It's up to controller code to
# reinitialize and restart the task.
logging.error("State not found for shard ID %r; shutting down",
shard_id)
return
if control and control.command == model.MapreduceControl.ABORT:
logging.info("Abort command received by shard %d of job '%s'",
shard_state.shard_number, shard_state.mapreduce_id)
if tstate.output_writer:
tstate.output_writer.finalize(None, shard_state.shard_number)
shard_state.active = False
shard_state.result_status = model.ShardState.RESULT_ABORTED
shard_state.put(config=util.create_datastore_write_config(spec))
model.MapreduceControl.abort(spec.mapreduce_id)
return
input_reader = tstate.input_reader
if spec.mapper.params.get("enable_quota", True):
quota_consumer = quota.QuotaConsumer(
quota.QuotaManager(memcache.Client()), shard_id,
_QUOTA_BATCH_SIZE)
else:
quota_consumer = None
ctx = context.Context(spec,
shard_state,
task_retry_count=self.task_retry_count())
context.Context._set(ctx)
try:
# consume quota ahead, because we do not want to run a datastore
# query if there's not enough quota for the shard.
if not quota_consumer or quota_consumer.check():
scan_aborted = False
entity = None
# We shouldn't fetch an entity from the reader if there's not enough
# quota to process it. Perform all quota checks proactively.
if not quota_consumer or quota_consumer.consume():
for entity in input_reader:
if isinstance(entity, db.Model):
shard_state.last_work_item = repr(entity.key())
else:
shard_state.last_work_item = repr(entity)[:100]
scan_aborted = not self.process_entity(
entity, ctx, tstate)
# Check if we've got enough quota for the next entity.
if (quota_consumer and not scan_aborted
and not quota_consumer.consume()):
scan_aborted = True
if scan_aborted:
break
else:
scan_aborted = True
if not scan_aborted:
logging.info("Processing done for shard %d of job '%s'",
shard_state.shard_number,
shard_state.mapreduce_id)
# We consumed extra quota item at the end of for loop.
# Just be nice here and give it back :)
if quota_consumer:
quota_consumer.put(1)
shard_state.active = False
shard_state.result_status = model.ShardState.RESULT_SUCCESS
if not shard_state.active:
# shard is going to stop. Finalize output writer if any.
if tstate.output_writer:
tstate.output_writer.finalize(ctx,
shard_state.shard_number)
# TODO(user): Mike said we don't want this happen in case of
# exception while scanning. Figure out when it's appropriate to skip.
ctx.flush()
finally:
context.Context._set(None)
if quota_consumer:
quota_consumer.dispose()
# Rescheduling work should always be the last statement. It shouldn't happen
# if there were any exceptions in code before it.
if shard_state.active:
self.reschedule(tstate)
def no_tx_get(i):
return db.get(keys[i:i + cls._MAX_STATES_IN_MEMORY])
def increment_counter(obj_key, counter_field_name, amount):
obj = db.get(obj_key)
setattr(obj, counter_field_name, getattr(obj, counter_field_name) + amount)
obj.put()
def handle(self):
"""Handle request."""
spec = model.MapreduceSpec.from_json_str(
self.request.get("mapreduce_spec"))
# TODO(user): Make this logging prettier.
logging.debug("post: id=%s headers=%s", spec.mapreduce_id,
self.request.headers)
state, control = db.get([
model.MapreduceState.get_key_by_job_id(spec.mapreduce_id),
model.MapreduceControl.get_key_by_job_id(spec.mapreduce_id),
])
if not state:
logging.error("State not found for mapreduce_id '%s'; skipping",
spec.mapreduce_id)
return
shard_states = model.ShardState.find_by_mapreduce_id(spec.mapreduce_id)
if state.active and len(shard_states) != spec.mapper.shard_count:
# Some shards were lost
logging.error(
"Incorrect number of shard states: %d vs %d; "
"aborting job '%s'", len(shard_states),
spec.mapper.shard_count, spec.mapreduce_id)
state.active = False
state.result_status = model.MapreduceState.RESULT_FAILED
model.MapreduceControl.abort(spec.mapreduce_id)
active_shards = [s for s in shard_states if s.active]
failed_shards = [
s for s in shard_states
if s.result_status == model.ShardState.RESULT_FAILED
]
aborted_shards = [
s for s in shard_states
if s.result_status == model.ShardState.RESULT_ABORTED
]
if state.active:
state.active = bool(active_shards)
state.active_shards = len(active_shards)
state.failed_shards = len(failed_shards)
state.aborted_shards = len(aborted_shards)
if (not state.active and control
and control.command == model.MapreduceControl.ABORT):
# User-initiated abort *after* all shards have completed.
logging.info("Abort signal received for job '%s'",
spec.mapreduce_id)
state.result_status = model.MapreduceState.RESULT_ABORTED
if not state.active:
state.active_shards = 0
if not state.result_status:
# Set final result status derived from shard states.
if [
s for s in shard_states
if s.result_status != model.ShardState.RESULT_SUCCESS
]:
state.result_status = model.MapreduceState.RESULT_FAILED
else:
state.result_status = model.MapreduceState.RESULT_SUCCESS
logging.info("Final result for job '%s' is '%s'",
spec.mapreduce_id, state.result_status)
# We don't need a transaction here, since we change only statistics data,
# and we don't care if it gets overwritten/slightly inconsistent.
self.aggregate_state(state, shard_states)
poll_time = state.last_poll_time
state.last_poll_time = datetime.datetime.utcfromtimestamp(self._time())
config = util.create_datastore_write_config(spec)
if not state.active:
# This is the last execution.
# Enqueue done_callback if needed.
if spec.mapper.output_writer_class():
spec.mapper.output_writer_class().finalize_job(state)
def put_state(state):
state.put(config=config)
done_callback = spec.params.get(
model.MapreduceSpec.PARAM_DONE_CALLBACK)
if done_callback:
done_task = taskqueue.Task(
url=done_callback,
headers={"Mapreduce-Id": spec.mapreduce_id})
queue_name = spec.params.get(
model.MapreduceSpec.PARAM_DONE_CALLBACK_QUEUE,
"default")
if not _run_task_hook(spec.get_hooks(),
"enqueue_done_task", done_task,
queue_name):
done_task.add(queue_name, transactional=True)
db.run_in_transaction(put_state, state)
return
else:
state.put(config=config)
processing_rate = int(
spec.mapper.params.get("processing_rate")
or model._DEFAULT_PROCESSING_RATE_PER_SEC)
self.refill_quotas(poll_time, processing_rate, active_shards)
ControllerCallbackHandler.reschedule(self.base_path(), spec,
self.serial_id() + 1)
def createNotificationMail(request, *args, **kwargs):
"""Appengine task that sends mail to the subscribed users.
Expects the following to be present in the POST dict:
comment_key: Specifies the comment id for which to send the notifications
task_key: Specifies the task key name for which the comment belongs to
Args:
request: Django Request object
"""
from soc.modules.gci.logic.helper import notifications as gci_notifications
from soc.modules.gci.logic.models import comment as gci_comment_logic
from soc.modules.gci.logic.models import task_subscription as \
gci_task_subscription_logic
# set default batch size
batch_size = 10
post_dict = request.POST
comment_key = post_dict.get('comment_key')
task_key = post_dict.get('task_key')
if not (comment_key and task_key):
# invalid task data, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid createNotificationMail data: %s' % post_dict)
comment_key = long(comment_key)
# get the task entity under which the specified comment was made
task_entity = gci_task_logic.logic.getFromKeyName(task_key)
# get the comment for the given id
comment_entity = gci_comment_logic.logic.getFromID(comment_key,
task_entity)
if not comment_entity:
# invalid comment specified, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid comment specified: %s/%s' % (comment_key, task_key))
# check and retrieve the subscriber_start_key that has been done last
idx = post_dict.get('subscriber_start_index', '')
subscriber_start_index = int(idx) if idx.isdigit() else 0
# get all subscribers to GCI task
fields = {
'task': task_entity,
}
ts_entity = gci_task_subscription_logic.logic.getForFields(fields,
unique=True)
subscribers = db.get(
ts_entity.subscribers[subscriber_start_index:subscriber_start_index +
batch_size])
task_url = "http://%(host)s%(task)s" % {
'host': system.getHostname(),
'task': redirects.getPublicRedirect(task_entity,
{'url_name': 'gci/task'}),
}
# create the data for the mail to be sent
message_properties = {
'task_url': task_url,
'redirect_url': "%(task_url)s#c%(cid)d" % {
'task_url': task_url,
'cid': comment_entity.key().id_or_name()
},
'comment_entity': comment_entity,
'task_entity': task_entity,
}
subject = DEF_TASK_UPDATE_SUBJECT_FMT % {
'program_name': task_entity.program.short_name,
'title': task_entity.title,
}
for subscriber in subscribers:
gci_notifications.sendTaskUpdateMail(subscriber, subject,
message_properties)
if len(subscribers) == batch_size:
# spawn task for sending out notifications to next set of subscribers
next_start = subscriber_start_index + batch_size
task_params = {
'comment_key': comment_key,
'task_key': task_key,
'subscriber_start_index': next_start
}
task_url = '/tasks/gci/task/mail/create'
new_task = taskqueue.Task(params=task_params, url=task_url)
new_task.add('mail')
# return OK
return http.HttpResponse()
def post(self, blog_id):
key = db.Key.from_path("Blog", int(blog_id), parent=blog_key())
post = db.get(key)
user_id = User.by_name(self.user.name)
comments_count = Comment.count_by_blog_id(post)
post_comments = Comment.all_by_blog_id(post)
likes = Like.by_blog_id(post)
unlikes = Unlike.by_blog_id(post)
previously_liked = Like.check_like(post, user_id)
previously_unliked = Unlike.check_unlike(post, user_id)
username = self.user.name
if self.user:
if self.request.get("like"):
puk = post.user.key().id()
ubn = User.by_name(self.user.name).key().id()
if puk != ubn: # These variables were only creatd to shorten the lenght of the line of code here since it was more than 79 chars.
if previously_liked == 0:
l = Like(post=post, user=User.by_name(self.user.name))
l.put()
time.sleep(0.1)
self.redirect('/post/%s' % str(post.key().id()))
else:
error = "You have already liked this post"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
error=error,
comments_count=comments_count,
post_comments=post_comments,
username=username)
else:
error = "It's not allowed to like your own posts"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
error=error,
comments_count=comments_count,
post_comments=post_comments,
username=username)
if self.request.get("unlike"):
puk = post.user.key().id()
ubn = User.by_name(self.user.name).key().id()
if puk != ubn:
if previously_unliked == 0:
ul = Unlike(post=post,
user=User.by_name(self.user.name))
ul.put()
time.sleep(0.1)
self.redirect('/post/%s' % str(post.key().id()))
else:
error = "You have already unliked this post"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
error=error,
comments_count=comments_count,
post_comments=post_comments,
username=username)
else:
error = "It's not allowed to unlike your own posts"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
error=error,
comments_count=comments_count,
post_comments=post_comments,
username=username)
if self.request.get("add_comment"):
comment_text = self.request.get("comment_text")
if comment_text:
c = Comment(post=post,
user=User.by_name(self.user.name),
text=comment_text)
c.put()
time.sleep(0.1)
self.redirect('/post/%s' % str(post.key().id()))
else:
comment_error = "Use the textarea to enter a post, please"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
comments_count=comments_count,
post_comments=post_comments,
comment_error=comment_error,
username=username)
if self.request.get("edit"):
puk = post.user.key().id()
ubn = User.by_name(self.user.name).key().id()
if puk == ubn:
self.redirect('/edit/%s' % str(post.key().id()))
else:
error = "To edit a post you must be the author"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
comments_count=comments_count,
post_comments=post_comments,
error=error,
username=username)
if self.request.get("delete"):
puk = post.user.key().id()
ubn = User.by_name(self.user.name).key().id()
if puk == ubn:
db.delete(key)
time.sleep(0.1)
self.redirect('/')
else:
error = "To delete a post you must be the author"
self.render("post.html",
post=post,
likes=likes,
unlikes=unlikes,
comments_count=comments_count,
post_comments=post_comments,
error=error,
username=username)
else:
self.redirect("/login")
def post(self):
key = self.request.get('key')
query = db.get(key)
db.delete(query)
self.response.out.write('message_%s' % key)
def get(self):
params_html = {}
user_author = ''
paper_key = self.request.get('i')
key = 'paper_%s' % paper_key
admin_flag = 0
temp = self.request.cookies.get('user_id')
if temp:
userid = valid_hash_cookie(temp)
if userid:
params_html['userid'] = userid
user = db.GqlQuery(
"SELECT * FROM UserPass_User WHERE user_id = '%s'" %
userid)
user = user.get()
if user:
admin_flag = user.isadmin
user_author = user.author_id
temp_flag = 1
try:
paper = db.get(paper_key)
except:
logging.error("%s", 'There is no paper with such a key')
temp_flag = 0
if temp_flag:
paper_desc = []
paper_desc.append(unescape_html(paper.title))
if (paper.publication_date):
paper_desc.append((paper.publication_date))
else:
paper_desc.append(int(paper.publication_year))
paper_desc.append(paper.publisher)
paper_desc.append(paper.authors_str)
paper_desc.append(paper.keywords)
paper_desc.append(unescape_html(paper.abstract))
paper_desc.append(paper.pdf_link)
paper_desc.append(paper.data_link)
paper_desc.append(paper.code_link)
paper_desc.append(paper.demo_link)
paper_desc.append(paper.biblio_str)
paper_desc.append(paper.web_link)
authors_links = []
for item in paper.authors:
authorID = item.replace(" ", "")
authorID = authorID.replace(",", "")
authors_links.append(authorID)
params_html['key'] = paper_key
params_html['admin_flag'] = admin_flag
params_html['paper'] = paper_desc
params_html['author_list'] = zip(paper.authors, authors_links)
params_html['paper_abstract'] = unescape_html(paper.abstract)
params_html['no_views'] = paper.no_views
params_html['no_pdf_downloads'] = paper.no_pdf_downloads
params_html['no_code_downloads'] = paper.no_code_downloads
params_html['no_demo_downloads'] = paper.no_demo_downloads
params_html['no_data_downloads'] = paper.no_data_downloads
if paper.demo_link:
if 'youtube' in paper.demo_link:
ind = paper.demo_link.find('watch?v=')
if ind:
youtube_key = paper.demo_link[ind +
8:len(paper.demo_link)]
params_html['youtube_demo'] = youtube_key
if admin_flag:
params_html['editpaper_link'] = "/_editpaper?i=" + paper_key
elif user_author in authors_links:
params_html['editpaper_link'] = "/_editpaper?i=" + paper_key
else:
params_html['editpaper_link'] = ''
#----------------Increase the Click Counter in the Database--------------
#pp = db.GqlQuery("SELECT * FROM Paper_Clicks_DB WHERE paperkey = '%s'" %paper_key)
#pp = pp.get()
pp = db.get(paper_key)
if pp:
pp.no_views = pp.no_views + 1
pp.put()
#------------------------------------------------------------------------
self.response.out.write(
template.render('./html/display_paper.html', params_html))
else:
self.redirect('/404?u=author')
def unassign_mentor_txn():
proposal = db.get(proposal_key)
proposal.mentor = None
proposal.has_mentor = False
db.put(proposal)
def post(self, topic_key):
topic = db.get(db.Key(topic_key))
if topic:
topic.stars = topic.stars - 1
topic.put()
memcache.set('Topic_' + str(topic.num), topic, 86400)
def retrieve_comment(self, comment_id):
key = db.Key.from_path('Comment', int(comment_id), parent=blog_key())
comment = db.get(key)
return comment
def get(self, post_id):
key = db.Key.from_path('BlogPost', int(post_id))
post_data = db.get(key)
if not post_data:
self.error(404)
self.render("mainpage.html", posts = [post_data])