def post(self): body2 = self.request.body j = json.loads(body2) usr = j["usr"] stream_to_sub = j["stream_name"] targetStream = stream_bundle.myStream.query( ancestor=management.stream_key(stream_to_sub)).fetch(1)[0] subStreamKey = targetStream.key streamIOwn_query = stream_bundle.stream_bundles.query( ancestor=management.stream_key(usr)).fetch(1) stream_bundles_entity = streamIOwn_query[0] stream_bundles_entity.stream_isublist.append(subStreamKey) stream_bundles_entity.put()
def get(self): inputText = self.request.get("query") print(inputText) print(type(inputText)) # A query string keyword = ".*" # print(keyword) # Build the Query and run the search query = search.Query(query_string=keyword) index = search.Index(name='ConnexStreamPool', namespace="Connex") result = index.search(query) streamlist = list() for doc in result.results: singleStream = \ stream_bundle.myStream.query(ancestor=management.stream_key(str(doc.fields[0].value))).fetch()[0] streamlist.append(singleStream.streamname) # for doc in result.results: # streamlist.append(str(doc.fields[0].value)) print(streamlist) output = [] for streamName in streamlist: if inputText in streamName: output.append(streamName) print(output) output = json.dumps(output) self.response.headers['Content-Type'] = 'application/json' self.response.out.write(output)
def post(self): try: stream_key = self.request.get("stream_key") #usrcomments = self.request.get("usrcomments") self.response.write(stream_key) myStream = stream_bundle.myStream.query( ancestor=management.stream_key(str(stream_key))).fetch(1)[0] #myStream.blob_key.append(upload.key()) #myStream.photoComments = [usrcomments] + myStream.photoComments for blob_info in self.get_uploads(): myStream.blob_key = [blob_info.key()] + myStream.blob_key myStream.imageCreateDateList = [ time.mktime(time.gmtime()) * 1000 ] + myStream.imageCreateDateList myStream.imageLocation = [ Location(longitude=random.uniform(-170, 170), latitude=random.uniform(-50, 50)) ] + myStream.imageLocation print(len(myStream.blob_key)) print(type(time.mktime(time.gmtime()) * 1000)) myStream.lastNewPicture = datetime.datetime.now() # modified the following code # print(self.get_uploads().__len__()) # print(myStream.numOfPictures) myStream.numOfPictures = myStream.numOfPictures + len( self.get_uploads()) # print(myStream.numOfPictures) myStream.put() self.redirect("/viewStream?Stream_id=" + stream_key) except: self.error(500)
def get(self): template = JINJA_ENVIRONMENT.get_template('myhtml/Trending.html') # get the top3 guys with stream names top3list = stream_bundle.top3streams.query().fetch()[0].top3list # fetch the streams stream_list = list() for stream in top3list: if str(stream) is not "": myStream = stream_bundle.myStream.query( ancestor=management.stream_key(str(stream))).fetch(1)[0] l_stream_name = myStream.streamname i_stream_blobkey = myStream.blob_key[0] i_stream_views = len(myStream.viewTimeQueue) i_stream = streamToShow(l_stream_name, i_stream_blobkey, i_stream_views) stream_list.append(i_stream) curr_usr = users.get_current_user() logout_url = users.create_logout_url('/') template_values = { 'usr': curr_usr, 'streams_to_show': stream_list, 'logout_url': logout_url, } self.response.write(template.render(template_values))
def post(self): stream_key = self.request.get("Stream_id") myStream_qurey = stream_bundle.myStream.query( ancestor=management.stream_key(str(stream_key))).fetch(1) if len(myStream_qurey) == 0: self.redirect("/myhtml/Errorpage.html?Error_code=404") return myStream = stream_bundle.myStream.query( ancestor=management.stream_key(str(stream_key))).fetch(1)[0] imagesToJquery = [] pic = image() # get image if any if (len(myStream.blob_key) > 0): image_blob_key_list = myStream.blob_key image_created_time_list = myStream.imageCreateDateList image_location_list = myStream.imageLocation for bbkey in image_blob_key_list: pic.url = images.get_serving_url(bbkey) imagesToJquery.append(copy.deepcopy(pic)) for i in range(len(image_created_time_list)): imagesToJquery[i].created = image_created_time_list[i] for i in range(len(image_location_list)): imagesToJquery[i].lat = image_location_list[i].latitude imagesToJquery[i].lng = image_location_list[i].longitude # for i in range(len(imagesToJquery)): # print(i) # print(imagesToJquery[i].url) # print(imagesToJquery[i].created) # print(imagesToJquery[i].lat) # print(imagesToJquery[i].lng) # # print(vars(imagesToJquery[i])) # print(imagesToJquery[i].__dict__) json_string = json.dumps([img.__dict__ for img in imagesToJquery]) print(json_string) # output = json.dumps(imagesToJquery) # obj_list = json.loads(json_string) # for obj in obj_list: # print("#") # print(obj['url']) # print(obj['created']) # print(obj['lat']) # print(obj['lng']) self.response.headers["Content-Type"] = "application/json" self.response.out.write(json_string)
def get(self): # A query string keyword = self.request.get('search_key') query = search.Query(query_string=keyword) index = search.Index(name='ConnexStreamPool', namespace="Connex") result = index.search(query) streamlist = list() for doc in result.results: singleStream = stream_bundle.myStream.query( ancestor=management.stream_key(str( doc.fields[0].value))).fetch()[0] streamlist.append(singleStream) stream_names = list() stream_owners = list() cover_urls = list() for stream in streamlist: if stream.numOfPictures > 0: l_stream_name = stream.streamname stream_names.append(l_stream_name) l_stream_owner = str(stream.streamOwner) if l_stream_owner.find("@") < 0: l_stream_owner = l_stream_owner + "@gmail.com" stream_owners.append(l_stream_owner) i_stream_coverurl = stream.urltoCoverPhoto hasCover = True i_stream_blobKey = "" if (i_stream_coverurl == ""): hasCover = False i_stream_blobKey = stream.blob_key[0] if (hasCover): cover_urls.append(i_stream_coverurl) else: cover_urls.append(images.get_serving_url(i_stream_blobKey)) if len(stream_names) > 0: hasResult = True else: hasResult = False dictPassed = { 'keyword': keyword, 'hasResult': hasResult, 'stream_names': stream_names, 'stream_owners': stream_owners, 'cover_url': cover_urls, } jsonObj = json.dumps(dictPassed, sort_keys=True) self.response.write(jsonObj)
def post(self): # A query string keyword = self.request.get('SearchInput') # Build the QueryOptions # Create a FieldExpression query_options = search.QueryOptions(limit=5, ) # Build the Query and run the search query = search.Query(query_string=keyword, options=query_options) index = search.Index(name='ConnexStreamPool', namespace="Connex") result = index.search(query) streamlist = list() for doc in result.results: singleStream = stream_bundle.myStream.query( ancestor=management.stream_key(str( doc.fields[0].value))).fetch()[0] streamlist.append(singleStream) streams_to_show = list() for stream in streamlist: if stream.numOfPictures > 0: l_stream_name = stream.streamname i_stream_coverurl = stream.urltoCoverPhoto hasCover = True i_stream_blobKey = "" if (i_stream_coverurl == ""): hasCover = False i_stream_blobKey = stream.blob_key[0] i_stream = streamToShow(l_stream_name, i_stream_coverurl, i_stream_blobKey, hasCover) streams_to_show.append(i_stream) curr_usr = users.get_current_user() logout_url = users.create_logout_url('/') if len(streams_to_show) > 0: hasResult = True else: hasResult = False template_values = { 'usr': curr_usr, 'streams_to_show': streams_to_show, 'logout_url': logout_url, 'hasResult': hasResult, } template = JINJA_ENVIRONMENT.get_template('myhtml/SearchHome.html') self.response.write(template.render(template_values))
def post(self): try: upload = self.get_uploads()[0] stream_key = self.request.get("stream_key") usrcomments = self.request.get("usrcomments") self.response.write(stream_key) myStream = stream_bundle.myStream.query(ancestor= management.stream_key(str(stream_key))).fetch(1)[0] #myStream.blob_key.append(upload.key()) myStream.photoComments = [usrcomments] + myStream.photoComments myStream.blob_key = [upload.key()] + myStream.blob_key myStream.lastNewPicture = datetime.datetime.now() myStream.numOfPictures = myStream.numOfPictures+1 myStream.put() self.redirect("/viewStream?Stream_id="+stream_key) except: self.error(500)
def post(self): upload = self.get_uploads()[0] stream_key = self.request.params['stream_id'] pic_lat = self.request.params['pic_lat'] pic_long = self.request.params['pic_long'] myStream = stream_bundle.myStream.query(ancestor= management.stream_key(str(stream_key))).fetch(1)[0] myStream.blob_key = [upload.key()] + myStream.blob_key myStream.lastNewPicture = datetime.datetime.now() myStream.numOfPictures = myStream.numOfPictures+1 myStream.pic_lat = [pic_lat] + myStream.pic_lat myStream.pic_long = [pic_long] + myStream.pic_long myStream.put() # some debug info dictPassed = {'pic_lat': pic_lat,'pic_long':pic_long,'stream_id':stream_key} jsonObj = json.dumps(dictPassed, sort_keys=True,indent=4, separators=(',', ': ')) self.response.write(jsonObj)
def get(self): stream_key = self.request.get("Stream_id") usr_launch_search = self.request.get('usr_launch_search') myStream = stream_bundle.myStream.query(ancestor= management.stream_key(str(stream_key))).fetch(1)[0] # increment the view number if usr other than owner view the stream l_stream_owner = str(myStream.streamOwner) if l_stream_owner.find("@") < 0: l_stream_owner = l_stream_owner+"@gmail.com" if(usr_launch_search != l_stream_owner): num_of_view = myStream.numOfViews myStream.numOfViews = num_of_view + 1; # get the view Time queue viewTimeQueue = myStream.viewTimeQueue currentTime = datetime.datetime.now() while len(viewTimeQueue)> 0 and (currentTime - viewTimeQueue[0]).seconds > 3600: del viewTimeQueue[0] viewTimeQueue.append(datetime.datetime.now()) myStream.viewTimeQueue = viewTimeQueue myStream.put() # get image if any if(len(myStream.blob_key) > 0): image_bolb_key_list = myStream.blob_key image_url = list() for bbkey in image_bolb_key_list: image_url.append(images.get_serving_url(bbkey)) weHaveImage = True else: weHaveImage = False image_url = list() dictPassed = { 'displayImages_name': stream_key, 'wehaveimage': weHaveImage, 'image_url': image_url, } jsonObj = json.dumps(dictPassed, sort_keys=True) self.response.write(jsonObj)
def post(self): body2 = self.request.body js_c = json.loads(body2) stream_id = js_c["stream_id"] numOfPage = js_c["page"] # fetch the urls myStream = stream_bundle.myStream.query(ancestor= management.stream_key(str(stream_id))).fetch(1)[0] blob_key_list = myStream.blob_key image_url = list() for bbkey in blob_key_list: image_url.append(images.get_serving_url(bbkey)) # self.response.write(image_url) i = (numOfPage-1)*3 j = i+3 # check boundarys endIndex = len(image_url)-1 if(i>endIndex): url_for_return = list() # empty list elif (j > endIndex): url_for_return = image_url[i:(endIndex+1)] else: url_for_return = image_url[i:j] a = [""]*3 s = list() for url in url_for_return: s.append(str(url)) a[0:len(s)] = s myUrls = { 'urls': s } self.response.write(json.dumps(myUrls))
def post(self): body2 = self.request.body j = json.loads(body2) streamName = j["name"] streamTag = j["tag"] urltocover = j["urltocover"] invitelist = j["emaillist"] add_msg = j['add_msg'] createDate = datetime.datetime.now() usr = users.get_current_user() # check if the stream is already created query_string = "stream_name: "+streamName query = search.Query(query_string=query_string) index = search.Index(name='ConnexStreamPool', namespace="Connex") result = index.search(query) for doc in result.results: singleStream = stream_bundle.myStream.query(ancestor= management.stream_key(str(doc.fields[0].value))).fetch() if(len(singleStream)>0 ): if(singleStream[0].streamname == streamName): Duplicate = { 'duplicate': "dup", 'aha': singleStream[0].streamname } self.response.write(json.dumps(Duplicate)) return # add the stream_name to our search database for later search operation # step1 create the document # get doc_id doc_id = stream_bundle.doc_id.query(ancestor=ndb.Key('Connex','Coonex')).fetch(1)[0] mydoc_id = doc_id.doc_id doc_id.doc_id = mydoc_id+1 doc_id.put() stream_document = search.Document( doc_id=str(mydoc_id), fields=[ search.TextField(name='stream_name', value=streamName) ] ) # step2 retrieve the index if not exit create one, index name is ConnexStreamPool myIndex = search.Index(name='ConnexStreamPool', namespace="Connex") # step3 put the document into the index myNewStream = stream_bundle.myStream(parent=stream_key(usr_name=streamName), streamOwner=usr, streamname=streamName, urltoCoverPhoto=urltocover, doc_id=stream_document.doc_id, lastNewPicture=None, createTime=createDate.date(), numOfPictures=0, numOfViews=0, ) myIndex.put(stream_document) newStreamKey = myNewStream.put() # get the stream_bundles streamIOwn_query = stream_bundle.stream_bundles.query( ancestor=stream_key(usr)).fetch(1) stream_bundles_entity = streamIOwn_query[0] stream_bundles_entity.stream_iownlist.append(newStreamKey) stream_bundles_entity.put() # at last we send out invite email if len(invitelist) > 0: self.inviteEmail(invitelist, add_msg)
def get(self): stream_key = self.request.get("Stream_id") usr = users.get_current_user() logout_url = users.create_logout_url('/') myStream_qurey = stream_bundle.myStream.query(ancestor= management.stream_key(str(stream_key))).fetch(1) if len(myStream_qurey) == 0: self.redirect("/myhtml/Errorpage.html?Error_code=404") return myStream = stream_bundle.myStream.query(ancestor= management.stream_key(str(stream_key))).fetch(1)[0] owner = myStream.streamOwner # increase the view by 1 if not view by owner if owner != usr: myStream.numOfViews = myStream.numOfViews +1 # get the view Time queue viewTimeQueue = myStream.viewTimeQueue currentTime = datetime.datetime.now() while len(viewTimeQueue)> 0 and (currentTime - viewTimeQueue[0]).seconds > 3600: del viewTimeQueue[0] viewTimeQueue.append(datetime.datetime.now()) myStream.viewTimeQueue = viewTimeQueue myStream.put() # test to see if this is the stream usr sub streamIOwn_query = stream_bundle.stream_bundles.query(ancestor=management.stream_key(usr)).fetch(1) stream_bundles_entity = streamIOwn_query[0] # get the list I sub listIsub = stream_bundles_entity.stream_isublist IsubthisStream = False for key in listIsub: if(key.get() is not None and key.get().streamname == stream_key): IsubthisStream = True break template = JINJA_ENVIRONMENT.get_template('myhtml/viewSingleStream.html') # step1 Create an upload URL if user want to upload pages upload_url = blobstore.create_upload_url('/viewSingleAfterUpload') # get image if any if(len(myStream.blob_key) > 0): image_bolb_key_list = myStream.blob_key image_url = [""]*3 counter = 0 for bbkey in image_bolb_key_list: image_url[counter]= images.get_serving_url(bbkey) counter = counter +1 if(counter == 3): break weHaveImage = True else: weHaveImage = False image_url = [""]*3 template_values = { 'owner': str(owner), 'usr': str(usr), 'blobstore_url': upload_url, 'stream_key': stream_key, 'haveImage': weHaveImage, 'imageUrl': image_url, 'IsubThisStream': IsubthisStream, 'logout_url': logout_url, } self.response.write(template.render(template_values))