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)