def post(self):
productID = self.request.get("productID")
mcuAdd = self.request.get("add")
mcuDel = self.request.get("del")
product = ndb.gql('SELECT * FROM Product WHERE productID=:1', productID).get()
schedule = ""
deleted = ""
if product is not None:
schedule = product.schedule
deleted = product.deleted
if product.toAdd == "":
product.toAdd = mcuAdd
else:
product.toAdd = product.toAdd +','+ mcuAdd
product.toAdd = product.toAdd
product.put()
idToDelete = str(mcuDel).split(',')
for id in idToDelete:
if id == '':
continue
user = ndb.gql('SELECT * FROM User WHERE fingerID=:1 limit 1', int(id)).get()
if user is not None:
user.key.delete()
memcache.set(key=productID, value=product.toAdd+"&"+mcuDel, time=86400)
self.response.out.write(
"""productID={2}&day={0}&time={1}&del={3}&sch={4}$""".format(
(datetime.datetime.today().weekday()+1)%6,
datetime.datetime.now().time(),
productID,
deleted,
schedule
)
)
else:
self.response.out.write('productID not found')
def post(self):
user = ndb.gql('SELECT * FROM User WHERE email=:1 limit 1', self.request.get("email")).get()
admin = ndb.gql('SELECT * FROM User WHERE email=:1 limit 1', self.request.get("admin")).get()
label = 'Fail'
message = 'No permission to delete';
if user.admin == admin.email:
if admin.email == admin.admin == user.email:
message = 'Please select <b>Delete Account</b> from the left menu to remove your account'
elif user.email == user.admin:
message = 'Cannot delete another admin'
else:
product = ndb.gql('SELECT * FROM Product WHERE productID=:1', admin.productID).get()
if product.deleted == "":
product.deleted = str(user.fingerID)
else:
product.deleted = product.deleted + ',' + str(user.fingerID)
product.put()
label = 'Success'
message = 'User <b>{0}</b> is deleted'.format(user.email)
user.key.delete()
obj = {
'action': 'delete',
'label': label, 'msg': message
}
self.response.out.write(json.dumps(obj))
def get(self):
userType = self.request.get('type')
query1 = ndb.gql("SELECT * FROM pendUserDetail WHERE userid = :1", userType)
query2 = ndb.gql("SELECT * FROM cfirmUserDetail WHERE userid = :1", userType)
ret1 = query1.fetch()
ret2 = query2.fetch()
if ret2 == [] and ret1 != []:
cPerson = cfirmUserDetail()
for i in ret1:
cPerson.userid = i.userid
cPerson.passwd = i.passwd
cPerson.email = i.email
cPerson.userName = i.userName
cPerson.ranNumber = i.ranNumber
cPerson.emailCodeUsed = "Yes"
cPerson.put()
template = JINJA.get_template('login.html')
self.response.write(template.render(
{ 'the_title': 'Welcome to the login page' ,
'verifydets': "Account has been verified, please log in!",
'noDisplayLinks': 'noDisplayLinks',
'action': '/processlogin'}
))
else:
template = JINJA.get_template('login.html')
self.response.write(template.render(
{ 'the_title': 'Welcome to the login page' ,
'noDisplayLinks': 'noDisplayLinks',
'action': '/processlogin',
'errors': ['User ID not on system or already verified']}
))
def get(self):
#### For upvoting complaints
user_id = self.request.get('user_id')
qa = ndb.gql('SELECT * FROM User WHERE google_id = :1', user_id)
userResult = qa.get()
if userResult is None: #need to create new user
name = self.request.get('name')
email = self.request.get('email')
pic = self.request.get('pic')
newuser = models.User(id=google_id,
name=name,
email=email,
google_id=google_id,
pic=pic)
newuser.put()
#
# ### Why the statement userkey = newuser
#
complaint_id = self.request.get('complaint_id')
c_id = int(complaint_id)
qb = ndb.Key('Complaint', c_id)
complaintResult = qb.get()
complaintResult.votes += 1
complaintResult.put()
#
qc = ndb.gql('SELECT * FROM User WHERE google_id = :1', user_id)
userResult = qc.get()
userResult.voted_set.append(qb)
userResult.put()
def get_or_create(cls, question_template, question, arguments,
answer_type):
"""
Retrieves the question or creates a new one
"""
if len(arguments) > 0:
q = ndb.gql(
""" SELECT * FROM Question
WHERE ANCESTOR IS KEY('Game', 'singleton')
AND question_template = :1
AND arguments IN :2""", question_template.key,
arguments).get()
else:
q = ndb.gql(
""" SELECT * FROM Question
WHERE ANCESTOR IS KEY('Game', 'singleton')
AND question_template = :1""",
question_template.key).get()
if not q:
q = cls(question_template=question_template.key,
question=question,
arguments=arguments,
answer_type=answer_type)
q.put()
return q
return q
def get(self):
allFacilities = ndb.gql("SELECT * FROM Facility").fetch()
cylinders = ndb.gql("SELECT * FROM Cylinder").fetch()
facilityName = {}
for facility in allFacilities:
facilityName[facility.key.urlsafe()] = facility.name
facilityStats = {}
for cylinder in cylinders:
if cylinder.currentFacility.urlsafe() not in facilityStats:
facilityStats[cylinder.currentFacility.urlsafe()] = {}
facilityStats[cylinder.currentFacility.urlsafe()]["name"] = facilityName[cylinder.currentFacility.urlsafe()]
if (facilityStats[cylinder.currentFacility.urlsafe()].get("fullCylinders")) :
facilityStats[cylinder.currentFacility.urlsafe()]["fullCylinders"] += 1
else:
facilityStats[cylinder.currentFacility.urlsafe()]["fullCylinders"] = 1
output = ""
for key in facilityStats:
output += facilityStats[key]["name"] + " " + str(facilityStats[key]["fullCylinders"]) + "\n"
logging.info("%s" %(output))
self.render({"facilityStats":facilityStats})
def get(self):
#### For upvoting complaints
user_id = self.request.get("user_id")
qa = ndb.gql("SELECT * FROM User WHERE google_id = :1", user_id)
userResult = qa.get()
if userResult is None: # need to create new user
name = self.request.get("name")
email = self.request.get("email")
pic = self.request.get("pic")
newuser = models.User(id=google_id, name=name, email=email, google_id=google_id, pic=pic)
newuser.put()
#
# ### Why the statement userkey = newuser
#
complaint_id = self.request.get("complaint_id")
c_id = int(complaint_id)
qb = ndb.Key("Complaint", c_id)
complaintResult = qb.get()
complaintResult.votes += 1
complaintResult.put()
#
qc = ndb.gql("SELECT * FROM User WHERE google_id = :1", user_id)
userResult = qc.get()
userResult.voted_set.append(qb)
userResult.put()
def post(self):
listOfChannels = self.request.get('remove')
link = self.request.get('linkToServer')
for channel in listOfChannels:
disqualify = 0
queryMC = ndb.gql("""SELECT * FROM Channel WHERE mine = :t AND id = :name""", t = "true", name = channel)
for current in queryMC:
queryMem = ndb.gql("""SELECT * FROM ChannelMember WHERE channel_id = :name""", name = channel)
for member in queryMem:
queryMemOfUs = ndb.gql("""SELECT * FROM ServerMember WHERE user_id = :name""", name = member.user_id)
for myMember in queryMemOfUs:
queryMemChannels = ndb.gql("""SELECT * FROM ChannelMember WHERE user_id = :name""", name = member.user_id)
for item in queryMemChannels:
if item.channel_id not in channels:
disqualify = 1
break
if disqualify == 0:
for channel in listOfChannels:
channelToSwitch = ChannelToSwitch(link = link, channel_id = channel)
channelToSwitch.put()
mesStat = AddMessageStatus (1 , 'success')
self.response.out.write(mesStat.to_JSON())
else:
mesStat = AddMessageStatus (0 , 'no can do')
self.response.out.write(mesStat.to_JSON())
def get(self):
weekday = datetime.today().weekday()
if (weekday<5): #This control limits blocks the emails on Sat and Sun
owa_key = "0d68f7a39b4bbc47ac1d14ffadcbe17a"
dashboard_name = self.request.get('dashboard_name', DEFAULT_DASHBOARD_NAME)
authors = ndb.gql("SELECT DISTINCT author.email FROM Rating")
for a in authors.fetch():
lastRatings = ndb.gql("SELECT * FROM Rating WHERE author.email = :1 ORDER by date desc LIMIT 1", a.author.email)
#today = datetime.strptime(datetime.now().strftime('%Y-%m-%d') , '%Y-%m-%d')
#lastRatings = lastRatings.filter("date =", today)
if lastRatings.get():
owa_lat = str(lastRatings.get().latitude)
owa_lon = str(lastRatings.get().longitude)
else:
owa_lat = "50.877861"
owa_lon = "5.958490"
page = urllib2.urlopen('http://api.openweathermap.org/data/2.5/weather?lat='+owa_lat
+'&lon=' + owa_lon + '&APPID=' + owa_key)
wjson = page.read()
statement = json.loads(wjson)
weather = Weather(parent=dashboard_key(dashboard_name))
weather.status = str(statement)
weather.user = a.author.email
weather.put()
def get(self):
weekday = datetime.today().weekday()
if (weekday <
5): #This control limits blocks the emails on Sat and Sun
owa_key = "0d68f7a39b4bbc47ac1d14ffadcbe17a"
dashboard_name = self.request.get('dashboard_name',
DEFAULT_DASHBOARD_NAME)
authors = ndb.gql("SELECT DISTINCT author.email FROM Rating")
for a in authors.fetch():
lastRatings = ndb.gql(
"SELECT * FROM Rating WHERE author.email = :1 ORDER by date desc LIMIT 1",
a.author.email)
#today = datetime.strptime(datetime.now().strftime('%Y-%m-%d') , '%Y-%m-%d')
#lastRatings = lastRatings.filter("date =", today)
if lastRatings.get():
owa_lat = str(lastRatings.get().latitude)
owa_lon = str(lastRatings.get().longitude)
else:
owa_lat = "50.877861"
owa_lon = "5.958490"
page = urllib2.urlopen(
'http://api.openweathermap.org/data/2.5/weather?lat=' +
owa_lat + '&lon=' + owa_lon + '&APPID=' + owa_key)
wjson = page.read()
statement = json.loads(wjson)
weather = Weather(parent=dashboard_key(dashboard_name))
weather.status = str(statement)
weather.user = a.author.email
weather.put()
def get_track_comments(request):
"""
Retrieves a list of comments according to the request
:param request: It contains all info needed to return
:type request: Libraries.Model.Request.Request
:return:List of comments
:rtype:Libraries.Model.TrackComment
"""
if request.comment is not None:
q = ndb.Key(urlsafe=request.comment)
q_comment = q.get()
return q_comment
query = "SELECT * FROM TrackComment "
constraints = []
if not request.retrieveAll:
if request.dtCreated is not None:
constraints.append("dtCreated = {}".format(request.dtCreated))
if request.rank is not None:
constraints.append("rank = {}".format(request.rank))
if request.user is not None:
constraints.append("user = '******'")
if request.track_id_url is not None:
q = ndb.Key(urlsafe=request.track_id_url)
constraints.append(" ANCESTOR IS {}".format(q))
if constraints:
query = query + " WHERE " + " AND ".join(constraints)
if request.order_by is not None:
query += " ORDER BY " + request.order_by + " " + (
" ASC " if request.order_asc else " DESC ")
if request.usePagination:
if request.cursor is not None:
curs = Cursor(urlsafe=request.cursor)
q, request.cursor, request.more = ndb.gql(query).fetch_page(
request.pageSize, start_cursor=curs)
else:
q, request.cursor, request.more = ndb.gql(query).fetch_page(
request.pageSize)
else:
q = ndb.gql(query)
result = []
for element in q:
user = str(element.user).repair()
comm = str(element.comment).repair()
rank = element.rank
track = element.key.parent().get()
comment = Libraries.Model.TrackComment.TrackComment(
user, comm, rank,
element.key.parent().urlsafe(),
element.key.parent().parent().urlsafe())
comment.artist_track = str(track.artist).repair()
comment.name_track = str(track.name).repair()
comment.dtCreated = element.dtCreated
comment.url_id = element.key.urlsafe()
result.append(comment)
return result
def get(self):
user = users.get_current_user()
#if login already
upload_url = blobstore.create_upload_url('/submit')
if user:
parent_key = ndb.Key('Persons', users.get_current_user().email())
query = ndb.gql("SELECT * "
"FROM Images "
"ORDER BY date DESC "
)
query2 = ndb.gql("SELECT *"
"from Liked_photos "
"WHERE ANCESTOR IS :1 "
"ORDER BY date DESC",
parent_key
)
template_values = {
'user_mail' : users.get_current_user().email(),
'user_name' : users.get_current_user().email().split("@")[0],
'logout' : users.create_logout_url(self.request.host_url),
'items' : query,
'upload_url' :upload_url,
'liked_photos' : query2,
'liked_photos_count' : query2.count(),
}
template = jinja_env.get_template('home.html')
self.response.out.write(template.render(template_values))
else :
template = jinja_env.get_template('welcome.html')
self.response.out.write(template.render())
def post(self):
if self.authenticate_user() and self.admin_logged_in() != True:
oldResults = ndb.gql(
"SELECT * FROM TestResults21 WHERE user = :user AND ANCESTOR is :ancestor ORDER BY created",
user=self.user_logged_in(),
ancestor=blog_key(DEFAULT_BLOG_NAME))
for oldResult in oldResults:
oldResult.key.delete()
print "result deleted"
questions = ndb.gql(
"SELECT * FROM TestQuestions21 WHERE ANCESTOR is :ancestor ORDER BY created",
ancestor=blog_key(DEFAULT_BLOG_NAME))
user = self.user_logged_in()
for question in questions:
question = question.question
choice = self.request.get(question)
current_choice = TestResults21(
user=user,
question=question,
choice=choice,
parent=blog_key(DEFAULT_BLOG_NAME))
current_choice.put()
print "choices saved in database"
self.redirect('/')
else:
self.redirect('/')
def show(self):
user = users.get_current_user()
if user: # signed in already
query_0 = ndb.gql("SELECT * "
"FROM University "
"WHERE budget_avg < 500 ")
query_500 = ndb.gql("SELECT * "
"FROM University "
"WHERE budget_avg >=500 AND budget_avg<1000")
query_1000 = ndb.gql("SELECT * "
"FROM University "
"WHERE budget_avg >=1000 AND budget_avg<1500")
query_1500 = ndb.gql("SELECT * "
"FROM University "
"WHERE budget_avg >=1500")
template_values = {
'username': users.get_current_user().nickname(),
'logout': users.create_logout_url(self.request.host_url),
'query_0': query_0,
'query_500': query_500,
'query_1000': query_1000,
'query_1500': query_1500,
'counter': countFav(),
}
template = jinja_environment.get_template('budgetpage.html')
self.response.out.write(template.render(template_values))
else:
self.redirect(users.create_login_url(self.request.uri))
def user_account(username):
result = User.query(User.name == username).fetch()
if result is None:
abort(404)
else:
user = result[0]
posts = ndb.gql(
"SELECT * FROM DatastoreFile WHERE user_email =:user_email ORDER BY time_stamp DESC",
user_email=user.email).fetch()
avatorQry = "SELECT user_email FROM DatastoreAvator"
avatorQryResult = ndb.gql(avatorQry).fetch()
avatorResult = [
item.user_email.encode("utf-8") for item in avatorQryResult
]
buyerQry = "SELECT buyer_email FROM DatastoreFile WHERE user_email='%s'" % (
user.email)
buyerQryResult = ndb.gql(buyerQry).fetch()
buyerResult = [item.buyer_email.encode("utf-8") for item in buyerQryResult]
return render_template('userAccount.html',
user=user,
posts=posts,
avatorResult=avatorResult,
buyerResult=buyerResult)
def show(self):
user = users.get_current_user()
if user: # signed in already
wanted_Budget = self.request.get('budget')
wanted_Rank = self.request.get('ranking')
wanted_Region = self.request.get('region')
query1 = ndb.gql("SELECT * "
"FROM University "
+ getbudget(wanted_Budget)
)
query2 = ndb.gql("SELECT * "
"FROM University "
+ getrank(wanted_Rank)
)
a_list = []
for i in query1:
for j in query2:
if i.name == j.name :
a_list.append(j)
if wanted_Region != 'none':
query3 = ndb.gql("SELECT * "
"FROM University "
"WHERE region =:1", getregion(wanted_Region)
)
b_list = []
for i in query3:
for j in a_list:
if i.name == j.name :
b_list.append(j)
queryfinal=b_list
else:
queryfinal = a_list
if not queryfinal:
checkRes = "Sorry, but your search has return no results."
else:
checkRes = ""
template_values = {
'username': users.get_current_user().nickname(),
'logout': users.create_logout_url(self.request.host_url),
'query' : queryfinal,
'counter': countFav(),
'checkRes' : checkRes,
'wanted_Budget' : wanted_Budget,
'wanted_Rank' : wanted_Rank,
'wanted_Region' : wanted_Region, #all this needed because of 'get' method to run query again to display same page
}
template = jinja_environment.get_template('filterpage.html')
self.response.out.write(template.render(template_values))
else:
self.redirect(users.create_login_url(self.request.uri))
def show(self):
user = users.get_current_user()
curr_user = ndb.Key('Persons', users.get_current_user().email())
if user: # signed in already
query = ndb.gql("SELECT * "
"FROM Favourites "
"WHERE ANCESTOR IS :1 ",
curr_user)
query2 = ndb.gql("SELECT * "
"FROM University "
)
a_list = []
for i in query:
for j in query2:
if i.fav_uni == j.name :
a_list.append(j)
template_values = {
'username': users.get_current_user().nickname(),
'logout': users.create_logout_url(self.request.host_url),
'query': a_list,
}
template = jinja_environment.get_template('userpage.html')
self.response.out.write(template.render(template_values))
else:
self.redirect(users.create_login_url(self.request.uri))
def show(self):
user = users.get_current_user()
if user: # signed in already
query_asia = ndb.gql("SELECT * "
"FROM University "
"WHERE region =:1", 'Asia')
query_aust = ndb.gql("SELECT * "
"FROM University "
"WHERE region =:1", 'Australia')
query_europe = ndb.gql("SELECT * "
"FROM University "
"WHERE region =:1", 'Europe')
query_america = ndb.gql("SELECT * "
"FROM University "
"WHERE region =:1", 'America')
template_values = {
'username': users.get_current_user().nickname(),
'logout': users.create_logout_url(self.request.host_url),
'query_asia': query_asia,
'query_aust': query_aust,
'query_europe': query_europe,
'query_america': query_america,
'counter': countFav(),
}
template = jinja_environment.get_template('regionpage.html')
self.response.out.write(template.render(template_values))
else:
self.redirect(users.create_login_url(self.request.uri))
def convertToDomainResults(self, arg_res, rankingCount):
final = []
listOfHotelIds = arg_res.keys()
newListOfHotels = map(encode, listOfHotelIds)
query = "Select * from HotelDetailMapClass where hotelId in " + str(tuple(newListOfHotels))
resultSet = ndb.gql(query)
#print 'hotel detail map size query: ' + str(len(resultSet))
hotelDetailMap = HotelDetailMapClass.GetJson(resultSet)
query = "Select * from ReviewMapClass where hotelId in " + str(tuple(newListOfHotels))
resultReviewMap = ndb.gql(query)
#print 'length of review map: ' + str(len(resultReviewMap))
reviewMap = ReviewMapClass.GetJson(resultReviewMap)
for hotelid in arg_res:
if hotelid in excludeList:
continue
obj = Hotel()
if hotelid not in hotelDetailMap:
print 'hotel not found in detail map: ' + hotelid
continue
hotel = hotelDetailMap[hotelid]
obj.name = hotel['title']
obj.address = hotel['address']
obj.images = hotel['images']
obj.match = 'not defined'
obj.hotelid = hotelid
attDetails = self.getAttributeDetails(hotelid)
attributeArr = []
random = self.findRandomDistribution()
count = 0
for quality in attDetails:
att = Attribute()
att.title = int(quality)
att.people = attDetails[quality][1]
att.percentageAttr = int(random[count])
count += 1
att.views = attDetails[quality][0]
attributeArr.append(att)
obj.attributes = attributeArr
reviewArr = []
totalReviews = arg_res[hotelid]
for rev, probability in totalReviews:
if hotelid not in reviewMap:
#print 'ERROR: Hotel id not found in review map: ' + str(hotelid)
continue
reviewTmp = reviewMap[hotelid]
rev_int = int(rev)
reviewObj = reviewTmp[rev_int]
reviewIns = Review()
reviewIns.review = reviewObj.get('review')
reviewIns.reviewer = reviewObj.get('ReviewerName')
reviewIns.location = reviewObj.get('Place')
reviewIns.image = reviewObj.get('ReviewerImage')
reviewIns.score = rankingCount[hotelid][rev]
reviewArr.append(reviewIns)
obj.reviews = reviewArr
final.append(obj)
return HotelCollection(items = final)
def post(self, url):
content = self.request.get("content")
version = self.request.get('v')
entryList = ndb.gql(
"SELECT * FROM Entry WHERE url='%s' ORDER BY version DESC LIMIT 1"
% url).fetch()
if content:
if version:
version = int(version)
entry = ndb.gql(
"SELECT * FROM Entry WHERE url='%s' AND version=%s" %
(url, version)).fetch()
if entry[0]:
entry[0].content = content
if entryList:
entry[0].version = entryList[0].version + 1
entry[0].put()
time.sleep(2)
self.redirect('/wiki%s' % url)
return
elif entryList:
version = entryList[0].version + 1
else:
version = 1
newEntry = Entry(url=url, content=content, version=version)
newEntry.put()
time.sleep(2)
self.redirect('/wiki%s' % url)
else:
self.render('newWiki.html',
content=content,
contentError="Content cannot be empty")
def get(self):
#clean up
q = "Select * from Reservation"
all = ndb.gql(q).fetch()
for a in all:
if a.endTime < datetime.datetime.now():
a.key.delete()
template = JINJA_ENVIRONMENT.get_template(
'webapp/templates/reservations.html')
user = users.get_current_user()
if user:
url = users.create_logout_url(self.request.uri)
url_linktext = 'Logout'
else:
url = users.create_login_url(self.request.uri)
url_linktext = 'Login'
entities = ndb.gql("Select * from Reservation").fetch()
template_values = {
'user': user,
'url': url,
'url_linktext': url_linktext,
'reservation': entities
}
self.response.write(template.render(template_values))
def get(self, url):
userCookie = self.request.cookies.get('user_id')
version = self.request.get('v')
if version:
#Get the specified version
version = int(version)
entry = ndb.gql(
"SELECT * FROM Entry WHERE url ='%s' AND version = %s" %
(url, version)).fetch()
else:
#Get the latest version
entry = ndb.gql(
"SELECT * FROM Entry WHERE url='%s' ORDER BY version DESC LIMIT 1"
% url).fetch()
if entry:
entry = entry[0]
self.render('Entry.html',
content=entry.content,
url=url,
cookie=userCookie,
version=version)
elif version:
self.response.write('Ther version %s does not exit!' % version)
elif userCookie:
self.redirect('/wiki/_edit%s' % url)
else:
self.response.write('Please log in for creating new entries!')
def get_all_projects_and_volunteers(self):
projects_list = []
query = ndb.gql("SELECT * FROM Project")
for p in query.fetch():
data_dict = collections.OrderedDict()
data_dict['id'] = str(p.id)
data_dict['name'] = str(p.name)
data_dict['date'] = str(p.date)
data_dict['category'] = str(p.category)
data_dict['location'] = str(p.location)
data_dict['volunteers'] = p.volunteers
data_dict['self'] = str(URL) + str("project/") + str(p.id)
projects_list.append(data_dict)
vols_list = []
query = ndb.gql("SELECT * FROM Volunteer")
for v in query.fetch():
data_dict = collections.OrderedDict()
data_dict['id'] = str(v.id)
data_dict['name'] = str(v.name)
data_dict['age'] = int(v.age)
data_dict['phone'] = str(v.phone)
data_dict['interests'] = str(v.interests)
data_dict['project'] = str(v.project)
data_dict['self'] = str(URL) + str("volunteer/") + str(v.id)
vols_list.append(data_dict)
projects_and_vols = {}
projects_and_vols['Projects'] = projects_list
projects_and_vols['Volunteers'] = vols_list
self.response.write(json.dumps(projects_and_vols))
def product(id):
if request.method == 'POST':
textBody = request.form.get("textBody")
post = PostText()
post.textBody = textBody
post.author_email = current_user.email
post.author_name = current_user.name
post.author_avator_link = current_user.avator_link
post.post_for_item = id
post.put()
current_user.postTexts.append(post)
current_user.put()
qry = "SELECT * FROM PostText WHERE post_for_item='%s' ORDER BY time_stamp DESC" % (id)
postTexts = ndb.gql(qry).fetch()
result = DatastoreFile.get_by_id(int(id))
if result:
postItem = result
entity = DatastoreFile.get_by_id(int(id))
recommendQry = "SELECT * FROM DatastoreFile WHERE category='%s' ORDER BY time_stamp DESC LIMIT 4" % (entity.category)
recommends = ndb.gql(recommendQry).fetch()
avatorQry = "SELECT user_email FROM DatastoreAvator"
Result = ndb.gql(avatorQry).fetch()
avatorResult = [item.user_email.encode("utf-8") for item in Result]
return render_template('product.html', postItem=postItem, postTexts=postTexts, recommends=recommends, avatorResult=avatorResult)
def get(self):
template = JINJA_ENVIRONMENT.get_template('webapp/templates/user.html')
id = self.request.get('id')
user = users.get_current_user()
if user:
url = users.create_logout_url(self.request.uri)
url_linktext = 'Logout'
query = "Select * from Reservation where userid=" + "'" + id + "' ORDER BY startTime ASC"
reservation = ndb.gql(query).fetch()
u_resources = "Select * from Resource where userid=" + "'" + id + "' ORDER BY lastRed DESC"
your_resources = ndb.gql(u_resources).fetch()
else:
url = users.create_login_url(self.request.uri)
url_linktext = 'Login'
template_values = {
'user': user,
'url': url,
'url_linktext': url_linktext,
'reservation': reservation,
'your_resources': your_resources
}
self.response.write(template.render(template_values))
def f_avgNumOfClients():
query = ndb.gql("""SELECT * FROM User""")
usersNum = query.count()
query = ndb.gql("""SELECT * FROM Server""")
serversNum = query.count()
avg = usersNum / (serversNum + 1)
return avg
def post(self):
#try:
user = users.get_current_user()
if user:
user = users.get_current_user().nickname()
else:
user = self.request.get('user')
#user = users.get_current_user().nickname()
#user = self.request.get('user')
dateTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
query = ndb.gql("""SELECT * FROM ChannelMember WHERE channel_id = :chan AND mine =:t """, chan = self.request.get('channel_id'), t = "true")
for member in query:
message = Message(id = self.request.get('text'), user_id = user, channel_id = self.request.get('channel_id'), text = self.request.get('text'), latitude = float(self.request.get('latitude')), longtitude = float(self.request.get('longtitude')), date_time = dateTime, to_who = member.user_id)
message.put()
#memb = messageShort (self.request.get('channel_id'), self.request.get('text') ,self.request.get('latitude'), self.request.get('longtitude'))
commandType = {'Content-Type': 'application/x-www-form-urlencoded'}
data = "{\"channel\":\"" + self.request.get('channel_id') + "\",\"text\":\"" + self.request.get('text') + "\",\"longtitude\":" + str(self.request.get('longtitude')) + ",\"latitude\":" + str(self.request.get('latitude')) + "}"
self.response.out.write(user)
self.response.out.write(data)
form_fields = {'user': user, 'action': 3, 'data': data}
query = ndb.gql("""SELECT * FROM Server""")
for current in query:
url = "http://" + current.link + "/update"
form_data = urllib.urlencode(form_fields)
result = urlfetch.fetch(url=url, payload=form_data, method=urlfetch.POST, headers=commandType)
self.response.out.write(result.content)
mesStat = AddMessageStatus (1 , 'success')
self.response.out.write(mesStat.to_JSON())
#except (RuntimeError, TypeError, NameError, ValueError):
mesStat = AddMessageStatus (0 , 'missing a tag')
self.response.out.write(mesStat.to_JSON())
def get(self):
# events_loc = []
events_build = []
events_dt_start = []
events_name = []
worker_name = self.request.get('worker_name')
delete_item = self.request.get('delete_item')
worker = ndb.gql("SELECT * FROM Crowdworker WHERE name = :1",worker_name).get()
if delete_item:
tmp = ndb.gql("SELECT * FROM Event WHERE name = :1",delete_item).get()
tmp.key.delete();
#ndb.delete()
events = ndb.gql("SELECT * FROM Event WHERE ANCESTOR IS :1", ndb.Key('author_name', worker_name))
for event in events:
# events_loc.append(event.loc)
events_build.append(event.building)
events_name.append(event.name)
events_dt_start.append(str(event.dt_start))
dictPassed = {'events_name':events_name, 'events_dt_start':events_dt_start,'events_build':events_build}
jsonObj = json.dumps(dictPassed, sort_keys=True,indent=4, separators=(',', ': '))
self.response.write(jsonObj)
def test_delete_package_ok(self):
caller = auth.Identity.from_bytes('user:[email protected]')
# Setup all sorts of stuff associated with a package.
self.register_fake_instance('a/b', 'a' * 40)
self.register_fake_instance('a/b', 'b' * 40)
self.service.set_package_ref('a/b', 'ref1', 'a' * 40, caller)
self.service.set_package_ref('a/b', 'ref2', 'b' * 40, caller)
self.service.attach_tags('a/b', 'a' * 40, ['tag1:tag1', 'tag2:tag2'],
caller)
self.service.attach_tags('a/b', 'b' * 40, ['tag1:tag1', 'tag2:tag2'],
caller)
# Another package, to make sure it stays alive.
self.register_fake_instance('c/d')
# Delete a/b and all associated stuff. Ensure entire entity group is nuked.
# The implementation of delete_package doesn't use this sort of query (and
# use explicit list of entity classes) as a reminder for future developers
# to be mindful about what they are deleting and how.
q = 'SELECT __key__ WHERE ANCESTOR IS :1'
self.assertTrue(ndb.gql(q, impl.package_key('a/b')).fetch())
self.service.delete_package('a/b')
self.assertFalse(ndb.gql(q, impl.package_key('a/b')).fetch())
self.assertFalse(self.service.get_instance('a/b', 'a' * 40))
# Another package is still fine.
self.assertTrue(self.service.get_instance('c/d', 'a' * 40))
def get(self):
#get artist:
url="www.yourlastube.com"
artists=[]
a=list(ndb.gql("select mbid from Artist"))
logging.error(a)
for i in a:
if i.mbid not in artist:
artists.append(i.mbid)
#get genres
query="select * from Genres order by genre"
data=list(ndb.gql(query))
genres=[]
for i in data:
if i.track_mbid is None:
pass
elif len(i.track_mbid)>=50:
logging.error(i.track_mbid)
genres.append(i)
artist_url=["www.yourlastube.com/artists"]
genre_url=["www.yourlastube.com/genres"]
a="/artist?mbid="
g="/genre?mbid="
for i in artists:
artist_url.append(url+a+i)
for i in genres:
genre_url.append(url+g+i)
logging.error(artist_url)
logging.error(genre_url)
def get(self,id):
user = users.get_current_user()
logout_url = users.create_logout_url('/')
p=ndb.gql("SELECT * from Chat where imageId=%d"%(int(id)))
chat=p.get()
chat=p.fetch()[0]
chat.clicks=chat.clicks+1
chat.put()
if user:
all_channels = Channels.all().fetch(1000)
count = len(all_channels)
content = ''
q = ndb.gql("SELECT * from Rec where imageId=%d ORDER BY date ASC"%(int(id)))
results = q.get()
results = q.fetch()
for entity in results:
content=content+str(entity.content)
channel_id = user.user_id()[0:15]
chat_token = channel.create_channel(channel_id)
template_values = {
'nickname':user.nickname(),
'chat_token': chat_token,
'chat':chat,
'logout_url': logout_url,
'count':count,
'content':content
}
template = jinja_environment.get_template('chat_page.html')
self.response.out.write(template.render(template_values))
else:
self.redirect(users.create_login_url(self.request.uri))
def thumps(imagekey,userid,imgid,direction):
v = ndb.gql("SELECT * FROM Vote WHERE imageid=:1 AND userid=:2",imagekey,userid)
if v.count()==0:
vote=Vote(imageid=imagekey,userid=userid,sign=direction)
vote.put()
else:
for vote in v:
vote.sign=direction
vote.put()
votes=ndb.gql("SELECT * FROM Vote WHERE imageid=:1",imagekey)
upcounter=0
downcounter=0
for vote in votes:
if vote.sign==1:
upcounter +=1
elif vote.sign==-1:
downcounter+=1
logging.info(upcounter)
logging.info(downcounter)
hotvalues=ndb.gql("SELECT * FROM Hot WHERE imageid=:1",imagekey)
for h in hotvalues:
hotvalue=hot(upcounter,downcounter,h.time)
h.hotvalue=hotvalue
h.votecounter= upcounter-downcounter
h.put()
votes=ndb.gql("SELECT * FROM Vote WHERE imageid=:1 and sign=:2",imagekey,1)
return json.dumps({"status" : "ok", "votes": votes.count(),"id":imgid, "action":direction})
def render_front(self, **kwargs):
debaters = ndb.gql("SELECT * FROM Debater")
adjudicators = ndb.gql("SELECT * FROM Adjudicator")
teams = ndb.gql("SELECT * FROM Teams")
adjs = ndb.gql("SELECT * FROM Adjudicator")
debInstitutes = []
adjInstitutes = []
for member in debaters:
if member.institute not in debInstitutes:
debInstitutes.append(member.institute)
for member in adjudicators:
if member.institute not in adjInstitutes:
adjInstitutes.append(member.institute)
values = {
'debaters' : debaters,
'adjudicators' : adjudicators,
'teams' : teams,
'adjs' : adjs,
'debInstitutes' : debInstitutes,
'adjInstitutes' : adjInstitutes
}
if kwargs:
for key, value in kwargs.items():
values[key] = value
self.render("desk.html", values)
def get(self):
username = self.request.cookies.get('username')
if username:
a = username.split('|')
name = ndb.gql("SELECT * FROM Account WHERE username=:1", a[0]).get().name
if checkRunner(name, a[1]):
matchup = ndb.gql("SELECT * FROM Matchups WHERE runner=:1", name)
if matchup.get():
for p in matchup:
t1 = p.team1
t2 = p.team2
team1 = ndb.gql("SELECT * FROM Teams WHERE teamName=:1", t1)
team2 = ndb.gql("SELECT * FROM Teams WHERE teamName=:1", t2)
matchup = matchup.get()
team1 = team1.get()
team2 = team2.get()
adjs = matchup.adjs.split(',')
adjs.pop()
values = {
'matchup' : matchup,
'adjs' : adjs,
'team1' : team1,
'team2' : team2
}
self.render("runner.html", values)
else:
self.redirect('/')
else:
self.redirect('/')
else:
self.redirect('/')
def _get_comment_likes_dislikes(self, comment_id):
likes = ndb.gql(('SELECT * FROM ActionModel WHERE CommentID = :1 '
'AND ActionType = :2'), comment_id, 'LIKE').count()
dislikes = ndb.gql(('SELECT * FROM ActionModel '
'WHERE CommentID = :1 AND ActionType = :2'),
comment_id, 'DISLIKE').count()
return likes, dislikes
def write_form(self, subject_choose=""):
session = self.session['Email']
subs = ndb.gql("select * from Subject where professor='"+session+"'")
sentence = "<select name='subject'>"
for sub in subs:
sentence2 = sentence + "<option value='"+sub.code+"'>"+sub.name+"</option>"
sentence = sentence2
sentence = sentence + "</select>"
self.response.out.write(formAddTask %
{"subject_choose": sentence
})
tasks = ndb.gql("SELECT * FROM Task where professor='"+session+"'")
count = ndb.gql("SELECT * FROM Task where professor='"+session+"'").count()
sentence2 = ""
if (count == 0):
self.response.out.write(
formTasks % {"tasks": "<p align='center'>You have not entered any task yet</p>"})
else:
for task in tasks:
sentence = "<tr><td>" + task.subjectCode + "</td><td>" + task.taskCode + "</td><td>" + task.description + "</td></tr>"
sentence2 = sentence2 + sentence
self.response.out.write(formTasks % {"tasks": sentence2+"</table><br/><p align='center'><a href='/professor'>Return</a></p>"})
def write_form(self, tasks_add="",tasks_delete=""):
session = self.session['Email']
self.response.out.write(formTasksDash %
{"tasks_add": "<a href='/newTask'>New task</a>",
"tasks_delete": "<a href='/deleteTask'>Delete Task</a>"
})
tasks = ndb.gql("SELECT * FROM Task where professor='" + session + "'")
count = ndb.gql("SELECT * FROM Task where professor='" + session + "'").count()
sentence2 = ""
if (count == 0):
self.response.out.write(
formTasks % {"tasks": "<p align='center'>You have not entered any task yet</p>"})
else:
for task in tasks:
sentence = "<tr><td>" + task.subjectCode + "</td><td>" + task.taskCode + "</td><td>" + task.description + "</td></tr>"
sentence2 = sentence2 + sentence
self.response.out.write(formTasks % {"tasks": sentence2})
def write_form(self, professor_sesion="", subject_professor="", rol_admin="", delete_admin=""):
rol = str(self.session['Rol'])
if rol != "professor":
self.response.write(formRestricted)
else:
session = self.session['Email']
self.response.out.write(formProfessor %
{"professor_session": session+" <a href='/logout'>Logout</a>",
"subject_professor": "<a href='/subject'>New subject</a>",
"rol_admin": "<a href='/Tasks'>Tasks</a>",
"delete_admin": "<a href='/delete'>Delete User</a>"})
subs = ndb.gql("SELECT * FROM Subject where professor='"+session+"'")
count = ndb.gql("SELECT * FROM Subject where professor='"+session+"'").count()
sentence2 = ""
if (count == 0):
self.response.out.write(
formSubjects % {"professor_subjects": "<p align='center'>You have not any subject assigned</p>"})
else:
for sub in subs:
sentence = "<tr><td>" + sub.code + "</td><td>" + sub.name + "</td><td>" + sub.description + "</td></tr>"
sentence2 = sentence2 + sentence
self.response.out.write(formSubjects % {"professor_subjects": sentence2})
def write_form(self, admin_session="", access_admin="", rol_admin="", delete_admin=""):
session = self.session['Email']
self.response.out.write(formAdmin %
{"admin_session": session+" <a href='/logout'>Logout</a>",
"access_admin": "<a href='/access'>Access</a>",
"rol_admin": "<a href='/rol'>Change Rol</a>",
"delete_admin": "<a href='/delete'>Delete User</a>"})
users = ndb.gql("SELECT * FROM User where email!='*****@*****.**'")
count = ndb.gql("SELECT * FROM User where email!='*****@*****.**'").count()
sentence2 = ""
if (count == 0):
self.response.out.write(
formUsers % {"user_access": "<p align='center'>There're not users in your database</p>"})
else:
for user in users:
sentence = "<tr><td>" + user.name + "</td><td>" + user.lastName + "</td><td>" + user.email + "</td><td>" + user.rol + "</td></tr>"
sentence2 = sentence2 + sentence
self.response.out.write(formUsers % {"user_access": sentence2})
def get(self, url):
userCookie = self.request.cookies.get('user_id')
version = self.request.get('v')
if version:
#Get the specified version
version = int(version)
entry = ndb.gql(
"SELECT * FROM Entry WHERE url ='%s' AND version = %s" % (url, version)).fetch()
else :
#Get the latest version
entry = ndb.gql(
"SELECT * FROM Entry WHERE url='%s' ORDER BY version DESC LIMIT 1" % url).fetch()
if entry:
entry = entry[0]
self.render('Entry.html', content=entry.content, url=url, cookie=userCookie, version=version)
elif version:
self.response.write('Ther version %s does not exit!' % version)
elif userCookie:
self.redirect('/wiki/_edit%s' % url)
else:
self.response.write('Please log in for creating new entries!')
def post(self, url):
content = self.request.get("content")
version = self.request.get('v')
entryList = ndb.gql(
"SELECT * FROM Entry WHERE url='%s' ORDER BY version DESC LIMIT 1" % url).fetch()
if content:
if version:
version = int(version)
entry = ndb.gql(
"SELECT * FROM Entry WHERE url='%s' AND version=%s" %(url, version)).fetch()
if entry[0]:
entry[0].content = content
if entryList:
entry[0].version = entryList[0].version + 1
entry[0].put()
time.sleep(2)
self.redirect('/wiki%s' % url)
return
elif entryList:
version = entryList[0].version + 1
else:
version = 1
newEntry = Entry(url=url,content=content,version=version)
newEntry.put()
time.sleep(2)
self.redirect('/wiki%s' % url)
else:
self.render('newWiki.html',
content=content,
contentError="Content cannot be empty"
)
def post(self):
game_id = self.request.path
game_id = game_id.replace('/game/', '')
game_id = game_id.replace('/action', '')
username = str(self.request.get('player'))
player = ndb.gql("SELECT * FROM Player WHERE name = '" + username + "'").fetch()
player = player[0]
game_status = ndb.gql("SELECT * FROM GameStatus WHERE name = '" + username + "' AND game_id = " + game_id).fetch()
game_status = game_status[0]
action = str(self.request.get('action'))
if action == "bet":
value = int(self.request.get('value'))
if value > player.tokens:
self.response.out.write("Bet more than the number of tokens you have")
else:
player.tokens -= value
game_status.tokens -= value
actions_array = json.decode(game_status.your_actions)
actions_array.append("play")
game_status.your_actions = json.encode(actions_array)
player.put()
game_status.put()
self.response.out.write("ok")
elif action == "play":
dealer = ndb.gql("SELECT * FROM Dealer WHERE game_id = " + game_id).fetch()
dealer = dealer[0]
deck = json.decode(dealer.deck)
card1 = choice(deck)
deck.remove(card1)
card2 = choice(deck)
deck.remove(card2)
player_cards = [card1, card2]
game_status.your_cards_visible = json.encode(player_cards)
game_status.put()
check_games = ndb.gql("SELECT * FROM GameStatus WHERE game_id = " + game_id).fetch()
check_num = 1
for game_s in check_games:
if len(json.decode(game_s.your_cards_visible)) != 2:
check_num = 0
if check_num == 1:
d_card1 = choice(deck)
deck.remove(d_card1)
d_card2 = choice(deck)
deck.remove(d_card2)
d_visible = json.decode(dealer.dealer_card_v)
d_visible.append(d_card1)
dealer.dealer_card_v = json.encode(d_visible)
dealer.dealer_card_n = d_card2
dealer.deck = json.encode(deck)
dealer.put()
self.response.out.write("ok")
# elif action == "draw":
#
# elif action == "fold":
#
# elif action == "doubledown":
else:
self.response.out.write("error")
def post(self):
user = ndb.gql('SELECT * FROM User WHERE email=:1 limit 1', self.request.get("email")).get()
admin = ndb.gql('SELECT * FROM User WHERE email=:1 limit 1', self.request.get("admin")).get()
label = 'Fail'
message = 'No permission to delete'
done = None
if admin.admin == admin.email:
schedule = self.request.get("schedule")
weekYear = self.request.get("weekYear")
if weekYear == "":
message = 'Please specify a week to schedule'
else:
weekYear = weekYear.split('-W')
week = str(weekYear[1])
year = str(weekYear[0])
today = datetime.date.today()
thisWeek = str(today.isocalendar()[1])
thisYear = str(today.year)
if week == thisWeek and year == thisYear:
product = ndb.gql('SELECT * FROM Product WHERE productID=:1', admin.productID).get()
if product.schedule == "":
product.schedule = "{0},{1}".format(str(user.fingerID), schedule)
else:
list = product.schedule.split(';')
i = 0
for data in list:
if str(user.fingerID) == data.split(',')[0]:
del list[i]
break
i += 1
product.schedule = ';'.join(list) + ";{0},{1}".format(str(user.fingerID), schedule)
product.put()
else:
if user.accessSchedule is None or user.accessSchedule == "":
accessSchedule = ["{0},{1},{2}".format(year, week, schedule)]
else:
accessSchedule = user.accessSchedule.split(';')
i = 0
for data in accessSchedule:
if not data:
break
weekSchedule = data.split(',')
if weekSchedule[0] == year and weekSchedule[1] == week:
del accessSchedule[i]
break
i += 1
accessSchedule.append("{0},{1},{2}".format(year, week, schedule))
user.accessSchedule = ';'.join(accessSchedule)
user.put()
label = 'Success'
message = 'User <b>{0}</b> has been rescheduled for Week {1}, {2}. It will take approximately 30 minutes for this change to take effect'.format(user.email, week, year)
else:
message = 'No permission to schedule'
obj = {
'action': 'schedule',
'label': label, 'msg': message,
'schedule': user.accessSchedule
}
self.response.out.write(json.dumps(obj))
def get_(self, user):
if users.is_current_user_admin():
if self.request.params.has_key('valid'):
self.genericGetCollection(ndb.gql("SELECT __key__ FROM DogOwnerRole WHERE valid=:1", self.request.params['valid'] == 'true'), "==> %s")
else:
self.genericGetCollection(ndb.gql("SELECT __key__ FROM DogOwnerRole"))
else:
self.request.set_status(401)
def get(self, id):
to_be_post = ndb.gql(
"Select * from Posts " + "Where user_id = :1 and status = 'TBP' ",
id).bind()
posted = ndb.gql(
"Select * from Posts " +
"Where user_id = :1 and status = 'Posted' ", id).bind()
template_values = {"posts": to_be_post, "posted": posted}
write_template(self, "list.html", template_values)
def _get_post_likes_dislikes_comment_count(self, post_id):
likes = ndb.gql(('SELECT * FROM ActionModel WHERE PostID = :1 '
'AND ActionType = :2'), post_id, 'LIKE').count()
dislikes = ndb.gql(('SELECT * FROM ActionModel '
'WHERE PostID = :1 AND ActionType = :2'), post_id,
'DISLIKE').count()
number_of_comments = ndb.gql(('SELECT * FROM CommentModel '
'WHERE PostID = :1'), post_id).count()
return likes, dislikes, number_of_comments
def post(self):
# get information from request body
user_data = json.loads(self.request.body)
#check if request body is valid
if (not checkRequestBody(self, user_data)):
return
#check if all required properties are provided
if ('first_name' not in user_data) or (
'last_name'
not in user_data) or ('username' not in user_data) or (
'email' not in user_data) or ('password' not in user_data):
badRequest(
self,
"First_name, last_name, username, email, and password are required"
)
return
#check if events is provided in user_data
if ('events' in user_data):
badRequest(self, "New user should start with empty events")
return
#check if username has been used
new_username = str(user_data['username'])
username_exist = ndb.gql("SELECT * FROM User WHERE username = '******'")
if (username_exist.count() > 0):
badRequest(self, "Username is in used.")
return
#check if email has been used
new_email = str(user_data['email'])
email_exist = ndb.gql("SELECT * FROM User WHERE email = '" +
new_email + "'")
if (email_exist.count() > 0):
badRequest(self, "Email is associated with another account")
return
#create new account
new_user = User(first_name=user_data['first_name'],
last_name=user_data['last_name'],
username=user_data['username'],
email=user_data['email'],
password=user_data['password'],
events=[])
new_user.put()
new_user.id = str(new_user.key.urlsafe())
new_user.put()
#create a self link and return
user_dict = new_user.to_dict()
user_dict['self'] = "/users/" + new_user.id
self.response.write(json.dumps(user_dict))
def get_track(request):
"""
Retrieves a list of tracks according to the request
:param request: The info to be retrieved
:type request: Libraries.Model.Request.TrackRequest
:return:List of tracks
:rtype:Libraries.Model.Track
"""
# if a URL key is specified ignore all the rest
if request.url_id is not None:
q = ndb.Key(urlsafe=request.url_id)
q_track = q.get()
return get_track_from_result(q_track)
query = "SELECT * FROM Track "
constraints = []
if not request.retrieveAll:
if request.artist is not None:
constraints.append("artist = '" + request.artist + "'")
if request.dtCreated is not None:
constraints.append("dtCreated = {}".format(request.dtCreated))
if request.rank is not None:
constraints.append("rank = {}".format(request.rank))
if request.album_id is not None:
q = ndb.Key(urlsafe=request.album_id)
constraints.append(" ANCESTOR IS {}".format(q))
if request.name is not None:
constraints.append("name >= '" + request.name + "' AND name < '" +
request.name + u"\ufffd'")
if constraints:
query = query + " WHERE " + " AND ".join(constraints)
if request.order_by is not None:
query += " ORDER BY " + request.order_by + " " + (
" ASC " if request.order_asc else " DESC ")
if request.top is not None:
query += " LIMIT {}".format(request.top)
if request.usePagination:
if request.cursor is not None:
q, request.cursor, request.more = ndb.gql(query).fetch_page(
request.pageSize, request.cursor)
else:
q, request.cursor, request.more = ndb.gql(query).fetch_page(
request.pageSize)
else:
q = ndb.gql(query)
result = []
for element in q:
result.append(get_track_from_result(element))
return result
def get(self):
adminExist = ndb.gql(
"SELECT * FROM TestUsers21 WHERE username = :user AND ANCESTOR is :ancestor ORDER BY created",
user="******",
ancestor=blog_key(DEFAULT_BLOG_NAME))
admin = adminExist.get()
if not admin:
hashed_password = self.make_temp_password('59543')
new_user = TestUsers21(username='******',
password=hashed_password,
parent=blog_key(DEFAULT_BLOG_NAME))
new_user.put()
print "new user created"
resultList = []
questions = ndb.gql(
"SELECT * FROM TestQuestions21 WHERE ANCESTOR is :1 ORDER BY created",
blog_key(DEFAULT_BLOG_NAME))
questionList = []
for question in questions:
questionList = []
votes = 0
questionList.append(question.question)
optionsQuery = ndb.gql(
"SELECT * FROM TestQuestions21 WHERE question = :question AND ANCESTOR is :ancestor ORDER BY created",
question=question.question,
ancestor=blog_key(DEFAULT_BLOG_NAME))
optionList = optionsQuery.get()
choicesList = []
for option in optionList.options:
choiceList = []
choiceList.append(option)
users = ndb.gql(
"SELECT * FROM TestResults21 WHERE question = :question AND choice = :choice AND ANCESTOR is :ancestor ORDER BY created",
question=question.question,
choice=option,
ancestor=blog_key(DEFAULT_BLOG_NAME))
userList = []
if users:
for user in users:
votes += 1
userList.append(user.user)
choiceList.append(userList)
choicesList.append(choiceList)
questionList.append(choicesList)
if votes == 0:
votes = 1
questionList.append(votes)
resultList.append(questionList)
self.render("results.html",
logged_in=self.authenticate_user(),
user=self.user_logged_in(),
admin=self.admin_logged_in(),
results=resultList)
def chatroom_all():
messages = ndb.gql('SELECT * FROM ChatMessage ORDER BY timestamp')
if request.method == 'POST':
user, message, timestamp = request.form.get('name'), request.form.get(
'message'), datetime.datetime.now()
chat_msg = ChatMessage(user=user, timestamp=timestamp, message=message)
chat_msg.put()
messages = ndb.gql('SELECT * FROM ChatMessage ORDER BY timestamp')
return render_template('chatroom.html',
messages=messages,
vm_time=vm_start_time,
mode='chatroom_all')
def get_album_comment(request):
"""
Return the comments for an album
:param request: The information of the comments to be retrieved
:type request: Libraries.Model.Request.CommentRequest
:return:List of comments
:rtype:Libraries.Model.AlbumComment
"""
query = "SELECT * FROM AlbumComment "
constraints = []
if not request.retrieveAll:
if request.comment is not None:
constraints.append("comment = '" + request.comment + "'")
if request.dtCreated is not None:
constraints.append("dtCreated = {}".format(request.dtCreated))
if request.rank is not None:
constraints.append("rank = {}".format(request.rank))
if request.user is not None:
constraints.append("user = '******'")
if request.album_id_url is not None:
q = ndb.Key(urlsafe=request.album_id_url)
constraints.append(" ANCESTOR IS {}".format(q))
if constraints:
query = query + " WHERE " + " AND ".join(constraints)
if request.order_by is not None:
query += " ORDER BY " + request.order_by + " " + (
" ASC " if request.order_asc else " DESC ")
if request.usePagination:
if request.cursor is not None:
q, request.cursor, request.more = ndb.gql(query).fetch_page(
request.pageSize, request.cursor)
else:
q, request.cursor, request.more = ndb.gql(query).fetch_page(
request.pageSize)
else:
q = ndb.gql(query)
result = []
for element in q:
user = str(element.user).repair()
comm = str(element.comment).repair()
rank = element.rank
comment = Libraries.Model.AlbumComment.AlbumComment(
comm, rank, user, element.key.parent())
comment.dtCreated = element.dtCreated
result.append(comment)
return result
def get_album(request):
"""
Retrieves a list of albums related to the request
:param request: Contains the data to be retrieved
:type request: Libraries.Model.Request.AlbumRequest
:return:List of Albums
:rtype:Libraries.Model.Album
"""
if request.url_id is not None:
q = ndb.Key(urlsafe=request.url_id)
q_track = q.get()
return get_album_from_result(q_track)
query = "SELECT * FROM Album "
constraints = []
if not request.retrieveAll:
if request.name is not None:
constraints.append("name >= '" + request.name + "' AND name < '" +
request.name + u"\ufffd'")
if request.artist is not None:
constraints.append("artist = '" + request.artist + "'")
if request.dtCreated is not None:
constraints.append("dtCreated = {}".format(request.dtCreated))
if request.rank is not None:
constraints.append("rank = {}".format(request.rank))
if constraints:
query = query + " WHERE " + " AND ".join(constraints)
if request.order_by is not None:
query += " ORDER BY " + request.order_by + " " + (
" ASC " if request.order_asc else " DESC ")
if request.top is not None:
query += " LIMIT {}".format(request.top)
if request.usePagination:
if request.cursor is not None:
q, request.cursor, request.more = ndb.gql(query).fetch_page(
request.pageSize, request.cursor)
else:
q, request.cursor, request.more = ndb.gql(query).fetch_page(
request.pageSize)
else:
q = ndb.gql(query)
result = []
for element in q:
result.append(get_album_from_result(element))
return result
def get(self):
# https://stackoverflow.com/questions/40023743/google-charts-date-axis-labels-not-correct
q = ndb.gql("SELECT * FROM Note ORDER BY date_created")
results = q.fetch()
ret = ''
for el in results:
# for Google Charts JS format: [new Date(2019, 5, 22), 37.8, 80.8, 41.8],
ret += "[new Date({}, {}-1, {}), {}, {}, {}],".format(
el.date_created.strftime("%Y"),
el.date_created.strftime("%-m"),
el.date_created.strftime("%-d"), el.db_nursery_no1,
el.db_nursery_no2, el.db_nursery_no3)
q = ndb.gql("SELECT * FROM Note ORDER BY date_created DESC")
results = q.fetch(1)
last_value_no1, last_value_no2, last_value_no3, date_created = '', '', '', ''
for el in results:
last_value_no1 = el.db_nursery_no1
last_value_no2 = el.db_nursery_no2
last_value_no3 = el.db_nursery_no3
date_created = el.date_created
end_value_nursery_no1 = last_value_no1 - start_value_nursery_no1
end_value_nursery_no2 = last_value_no2 - start_value_nursery_no2
end_value_nursery_no3 = last_value_no3 - start_value_nursery_no3
evno1 = "{0:+}".format(end_value_nursery_no1)
evno2 = "{0:+}".format(end_value_nursery_no2)
evno3 = "{0:+}".format(end_value_nursery_no3)
yesterday = date_created - datetime.timedelta(days=1)
id_date = yesterday.strftime("%Y-%m-%d")
k = ndb.Key('Note', id_date)
e = k.get()
day2day_nursery_no1 = last_value_no1 - e.db_nursery_no1
day2day_nursery_no2 = last_value_no2 - e.db_nursery_no2
day2day_nursery_no3 = last_value_no3 - e.db_nursery_no3
d2dno1 = "{0:+}".format(day2day_nursery_no1)
d2dno2 = "{0:+}".format(day2day_nursery_no2)
d2dno3 = "{0:+}".format(day2day_nursery_no3)
template_context = {
'body': ret,
'last_score_db_nursery_no1': last_value_no1,
'last_score_db_nursery_no2': last_value_no2,
'last_score_db_nursery_no3': last_value_no3,
'evno1': evno1,
'evno2': evno2,
'evno3': evno3,
'd2dno1': d2dno1,
'd2dno2': d2dno2,
'd2dno3': d2dno3
}
template = jinja_env.get_template('templates/chart.html')
self.response.out.write(template.render(template_context))
def delete(self):
# query for events from datastore
event_query_objects = ndb.gql("SELECT * FROM Event")
# 1 - get each event from query
# 2 - create a history event and add to history datastore
# 3 - remove event from user's account
if (event_query_objects.count() > 0):
for event_query in event_query_objects:
event_key = ndb.Key(urlsafe=event_query.key.urlsafe())
event = event_key.get()
# create a history event entity
history = EventHistory(name=event.name,
date=event.date,
time=event.time,
description=event.description,
all_day=event.all_day,
account_id=event.account_id,
event_id=event.id)
history.put()
#get history id
history.id = str(history.key.urlsafe())
history.put()
# remove event from user's account
user_query_object = ndb.gql("SELECT * FROM User WHERE id = '" +
event.account_id + "'")
if (user_query_object.count() > 0):
for user_query in user_query_object:
# get user
user_key = ndb.Key(urlsafe=str(event.account_id))
user = user_key.get()
# loop through user's events list
for e in xrange(len(user.events)):
# look for event to be deleted in user's events list
# when found, remove event from user's events list
if (user.events[e]['id'] == event.id):
user.events.pop(e)
break
# update changes to user
user.put()
#delete event from datastore
event.key.delete()
def feed_sequence_update_daily(self):
logging.info("In feed_sequence_update_daily")
cursor_from_url = self.request.get('cursor')
logging.info("Cursor in start is: {}".format(cursor_from_url))
#process_date = util_misc.get_start_date_from_day_param(self)
gql_query_text = 'Select * From TestSequences' #Define query conditions here
#Execute query
#query_o = db.GqlQuery(gql_query_text, process_date)
query_o = ndb.gql(gql_query_text)
if cursor_from_url:
query_o.fetch()
BATCH_SIZE = 500
results = query_o.fetch(BATCH_SIZE)
else:
BATCH_SIZE = 1
results = query_o.fetch(BATCH_SIZE)
if not results:
logging.info("feed_sequence_update_second_task: all done")
return
logging.info("result is {}".format(results))
#Calling fn to insert data in FeedSequence
record_type = 'daily'
FeedModelCheck.add_feeds_sequences_records(self,results,record_type)
cursor = query_o.fetch(5)
taskqueue.add(url='/admin/feed/add-top-searches-daily', params={'cursor': cursor})
logging.info("Exiting feed_sequence_update_daily")
return
def post(self):
username = self.request.get("username")
password = self.request.get("password")
input_user_hash = make_user_hash(username)
userrequest = ndb.gql("Select * FROM User WHERE username = '******'" %
input_user_hash)
req = userrequest.get()
if req:
req_user = req.username
req_pass = req.password
input_pass_hash = make_pw_hash(username, password, req_pass)
logging.error("req_pass = %s and input_pass_hash = %s" %
(req_pass, input_pass_hash))
#logging.error ("req_user = %s and input_user_hash = %s" % (req_user, input_user_hash))
if input_pass_hash == req_pass:
self.response.headers.add_header(
'Set-Cookie', 'user=%s;Path=/' % str(req_user))
self.redirect("/welcome")
else:
error = "Login and Pass Do not Match"
self.render("userlogin.html", pass_error=error)
else:
error = "Username Not Found"
self.render("userlogin.html", user_error=error)
def show(self):
user_id = users.get_current_user().user_id()
if user_id == None:
self.redirect(users.create_login_url(self.request.uri))
else:
user = ndb.Key('Person', user_id).get()
if user == None or user.setup == None or user.setup == False:
self.redirect('/setup')
else:
games = ndb.gql(
"SELECT * "
"FROM Game "
"WHERE ANCESTOR IS :1 "
"ORDER BY date DESC",
ndb.Key('Playlist',
user_id,
parent=ndb.Key('Person', user_id)))
template_values = {
'img_url': user.img_url,
'display_name': user.display_name,
'logout': users.create_logout_url(self.request.host_url),
'games': games,
}
template = JINJA_ENVIRONMENT.get_template('playlist.html')
self.response.out.write(template.render(template_values))
def show(self):
user = users.get_current_user()
if user:
parent_key = ndb.Key('Persons', users.get_current_user().email())
query = ndb.gql("SELECT * "
"FROM Images "
"WHERE ANCESTOR IS :1 "
"ORDER BY date DESC",
parent_key)
upload_url = blobstore.create_upload_url('/submit')
template_values = {
'user_mail' : users.get_current_user().email(),
'user_name' : users.get_current_user().email().split("@")[0],
'logout' : users.create_logout_url(self.request.host_url),
'items' : query,
'items_num' : query.count(),
'upload_url' : upload_url,
}
template = jinja_environment.get_template("upload.html")
self.response.out.write(template.render(template_values))
else :
self.redirect(self.request.host_url)
