def get(self):
self.set_content_text_plain()
response = {}
# get stream name
stream_id = self.get_request_param(fh.stream_id_parm)
response[fh.stream_id_parm] = stream_id
if stream_id is None or stream_id == "":
fh.bad_request_error(
self, response,
'No parameter {} found'.format(fh.stream_id_parm))
return
# get the stream
stream = Stream.get_by_id(stream_id)
if stream is None:
fh.bad_request_error(self, response, 'Invalid Stream ID')
return
# check that user is the owner of the stream
user_id = self.get_request_param(fh.user_id_parm)
if user_id != stream.get_owner_from_db().user_id():
fh.bad_request_error(self, response, 'Not stream owner')
return
# remove stream name entries from the search index
fh.remove_stream_from_search_index(stream, response)
# delete the stream
stream.delete()
self.write_response(json.dumps(response))
def get(self):
self.set_content_text_plain()
response = {}
# get current user
user_id = self.get_request_param(fh.user_id_parm)
if user_id in ['', None]:
fh.bad_request_error(
self, response,
'No parameter {} found'.format(fh.user_id_parm))
return
user = StreamUser.get_by_id(user_id)
if user is None:
fh.bad_request_error(self, response, 'Invalid user')
return
# query for all streams owned by user
my_streams = Stream.get_ids_by_owner(user)
# query for all streams subscribed to by user
sub_streams = StreamSubscriber.get_by_user(user)
# write some stream info
response['owned_streams'] = [s for s in my_streams]
response['subscribed_streams'] = [s.stream.id() for s in sub_streams]
self.write_response(json.dumps(response))
def get(self):
#If parameter of id=, then return only the items with that streams ID.
#Otherwise return all items.
self.set_content_text_json()
response = []
streamid = self.get_request_param("streamid")
if (streamid == None) or (streamid == ''):
my_stream_items = StreamItem.get_all_stream_items()
else:
my_stream_items = StreamItem.get_stream_items_by_key(long(streamid))
for item in my_stream_items:
dictItem = {"streamid": item.stream.id(),
"streamname": Stream.get_by_id(item.stream.id()).name,
"imageurl": item.URL,
"dateadded": item.dateAdded.strftime('%Y-%m-%d %H:%M:%S'),
"lat": item.latitude,
"lng": item.longitude}
response.append(dictItem)
print(response)
self.write_response(json.dumps(response))
def get(self):
self.set_content_text_plain()
response = {}
# get current user
owner_id = self.get_request_param(fh.user_id_parm)
owner = StreamUser.get_by_id(owner_id)
if owner is None:
fh.bad_request_error(self, response, 'Not logged in')
return
# get stream name
stream_name = self.get_request_param(fh.stream_name_parm)
response[fh.stream_name_parm] = stream_name
if stream_name is None or stream_name == "":
fh.bad_request_error(
self, response,
'No parameter {} found'.format(fh.stream_name_parm))
return
# get cover image URL
cover_url = self.get_request_param(fh.cover_url_parm)
response[fh.cover_url_parm] = cover_url
# create new stream
stream = Stream.create(name=stream_name,
owner=owner,
cover_url=cover_url)
if stream is None:
fh.bad_request_error(
self, response,
'Stream {0} already exists for user {1}'.format(
stream_name, owner.nickName))
return
response[fh.stream_id_parm] = stream.key.id()
# add stream to document index for searching
fh.searchablize_stream(stream, response)
# process subscribers list
subs = self.get_request_param(fh.subscribers_parm)
response[fh.subscribers_parm] = subs
num_added = StreamSubscriber.add_subscribers_by_emails(
stream, subs.split(';'))
response['num_new_subscribers'] = num_added
# process tags list
#TODO: tags list in create
tags = self.get_request_param(fh.tags_parm)
StreamTag.add_tags_to_stream_by_name(stream, tags.split(';'))
response[fh.tags_parm] = tags
response['status'] = "Created new stream: {}".format(stream_name)
self.write_response(json.dumps(response))
def get(self):
self.set_content_text_plain()
response = {}
# get stream name
stream_id = self.get_request_param(fh.stream_id_parm)
response[fh.stream_id_parm] = stream_id
if stream_id in [None, '']:
fh.bad_request_error(
self, response,
'No parameter {} found'.format(fh.stream_id_parm))
return
# get the stream
stream = Stream.get_by_id(stream_id)
if stream is None:
fh.bad_request_error(self, response, 'Invalid Stream ID')
return
# get tag name
tag_name = self.get_request_param(fh.tag_name_parm)
if tag_name in [None, '']:
fh.bad_request_error(
self, response,
'No parameter {} found'.format(fh.tag_name_parm))
return
# check how many streams have this tag
st = StreamTag.get_batch_by_tag_name(tag_name)
n_streams = len(st)
# get the tag
tag = Tag.get_by_name(tag_name)
if tag is not None:
# remove streamtags
StreamTag.delete_tag_from_stream(stream, tag)
# block until new tag is found
time.sleep(0.01)
while StreamTag.get_by_stream_and_tag(stream, tag) is not None:
time.sleep(0.01)
if n_streams == 1:
fh.remove_tag_from_search_index(tag_name, {})
tag.delete()
redirect_url = str(self.get_request_param(fh.redirect_parm))
if redirect_url in ['', None]:
self.write_response(json.dumps(response))
else:
self.redirect(redirect_url)
def get(self):
self.set_content_text_json()
response = []
# get stream IDs
# if none found, return all
stream_id = self.get_request_param(fh.stream_id_parm)
if stream_id in ['', None]:
all_streams = Stream.get_all_streams_by_updated()
for stream in all_streams:
response.append(stream.get_meta_dict())
else:
ids = json.loads(stream_id)
try:
for id in ids:
response.append(Stream.get_meta_dict_by_id(id))
except TypeError:
response.append(Stream.get_meta_dict_by_id(ids))
print(response)
self.write_response(json.dumps(response))
def get(self):
self.set_content_text_plain()
response = {}
# get stream name
stream_id = self.get_request_param(fh.stream_id_parm)
response[fh.stream_id_parm] = stream_id
if stream_id in ['', None]:
fh.bad_request_error(
self, response,
'No parameter {} found'.format(fh.stream_id_parm))
return
# get the stream
stream = Stream.get_by_id(stream_id)
if stream is None:
fh.bad_request_error(self, response, 'Invalid Stream ID')
return
# get tag name
tag_name = self.get_request_param(fh.tag_name_parm)
if tag_name in ['', None]:
fh.bad_request_error(
self, response,
'No parameter {} found'.format(fh.tag_name_parm))
return
# get the tag
tag = Tag.get_or_create_by_name(tag_name.strip().lower())
# create new streamtag
StreamTag.add_tags_to_stream_by_name(stream, [tag.name])
# block until new tag is found
time.sleep(0.01)
while StreamTag.get_by_stream_and_tag(stream, tag) is None:
time.sleep(0.01)
redirect_url = str(self.get_request_param(fh.redirect_parm))
if redirect_url in ['', None]:
self.write_response(json.dumps(response))
else:
self.redirect(redirect_url)
def get(self):
user = StreamUser.get_current_user(self)
if user:
login_url = fh.get_logout_url(self, '/')
login_text = 'Sign out'
else:
self.redirect("/")
return
template_values = {
'html_template': 'MasterTemplate.html',
'user': user.nickName,
'login_url': login_url,
'login_text': login_text,
'stream_name_parm': fh.stream_name_parm,
'tags_parm': fh.tags_parm,
'cover_url_parm': fh.cover_url_parm,
'subs_parm': fh.subscribers_parm
}
search_string = self.get_request_param(fh.search_string_parm)
if search_string is not None:
template_values['search_string'] = search_string
tags = self.get_request_param(fh.tags_parm)
if tags not in [None, '']:
s = urllib.unquote(tags).decode('utf8')
tags = eval(s)
template_values['search_tags'] = [{
'name': tag,
'url': fh.get_viewtag_url(tag)
} for tag in tags]
stream_ids = self.get_request_param(fh.stream_id_parm)
if stream_ids not in [None, '']:
s = urllib.unquote(stream_ids).decode('utf8')
ids = eval(s)
template_values['search_streams'] = Stream.get_batch_by_ids(ids)
path = os.path.join(os.path.dirname(__file__),
'../../templates/StreamSearch.html')
self.set_content_text_html()
self.write_response(fh.render_html_template(path, template_values))
def rebuild_stream_index():
# get all existing stream names
all_streams = Stream.get_all_streams()
# define new tag search index name
if fh.get_stream_index_name() == "stream_index":
new_index_name = "stream_index_alt"
else:
new_index_name = "stream_index"
# empty the new index
empty_index(new_index_name)
# add all tags to new index
for stream in all_streams:
fh.searchablize_tag_or_stream(stream, new_index_name, {})
# switch primary search
fh.set_stream_index_name(new_index_name)
def post(self):
user = StreamUser.get_current_user(self)
if user is None:
self.redirect("/")
return
# make call to deleteStream service
button = self.get_request_param('button')
if button == "Cancel":
self.redirect('/manage?{0}=Delete cancelled'.format(fh.message_parm))
return
reg = re.compile(r'^delete_(.*)')
matches = [reg.match(key) for key in self.get_request_parameter_dictionary().keys()]
stream_ids = [str(match.groups()[0]) for match in matches if match is not None]
message = ""
for id in stream_ids:
delete_stream_url = 'http://{0}/services/deletestream?{1}={2};{3}={4}'.format(os.environ['HTTP_HOST'],
fh.stream_id_parm,
id,
fh.user_id_parm,
StreamUser.get_current_user(self).user_id())
try:
result = urllib2.urlopen(delete_stream_url)
message = "{0}, {1}".format(message, result)
except urllib2.HTTPError:
self.redirect('/error?{0}={1}'.format(fh.message_parm, 'Error deleting stream'))
# try to wait until streams are really gone...
for id in stream_ids:
while Stream.get_by_id(id):
pass
self.redirect('http://{0}/manage?{1}={2}'.format(os.environ['HTTP_HOST'], fh.message_parm, 'Deleted streams'))
def post(self):
response = {}
# get current user
try:
user = StreamUser.get_current_user(self)
except urllib2.HTTPError:
fh.bad_request_error(self, response, 'HTTPERROR... authToken = {}'.format(self.get_request_param(fh.auth_token_parm)))
return
if user is None:
fh.bad_request_error(self, response, 'Not logged in')
return
stream_id = self.get_request_param(fh.stream_id_parm)
if stream_id is None or stream_id == '':
fh.bad_request_error(self, response, 'No parameter {} found'.format(fh.stream_id_parm))
return
# get the stream
stream = Stream.get_by_id(stream_id)
if stream is None:
fh.bad_request_error(self, response, 'Invalid Stream ID')
return
n_ups = max(1, fh.get_num_uploads(self))
print('\nThere were {} uploads\n'.format(n_ups))
for i in range(n_ups):
upload = fh.get_upload_from_filehandler(self, i)
url = self.get_request_param(fh.url_parm)
if upload is not None:
image_url = fh.get_file_url(upload)
name = upload.filename
elif url not in [None, '']:
try:
urllib2.urlopen(url)
image_url = url
name = upload
except:
image_url = None
else:
image_url = None
if image_url is not None:
iscover = self.get_request_param('iscover')
if iscover:
stream.set_cover_image_url(image_url)
else:
lat = self.get_request_param('lat')
print "Latitude = ", lat
lng = self.get_request_param('lng')
print "Longitude = ", lng
# create StreamItem entity
item = StreamItem.create(
owner=user,
file=upload,
URL=image_url,
name=name,
stream=stream,
latitude=lat,
longitude=lng)
# update stream list of images
stream.add_item(item)
# go back to viewstream page
redirect = str(self.get_request_param(fh.redirect_parm))
if redirect:
self.redirect(redirect)
return
else:
self.set_content_text_plain()
response = {'status': 'Upload successful',
'image_url': image_url
}
self.write_response(json.dumps(response))
return
def get(self):
self.set_content_text_plain()
response = {}
stream_id = self.get_request_param(fh.stream_id_parm)
if stream_id is None or stream_id == '':
fh.bad_request_error(
self, response,
'No parameter {} found'.format(fh.stream_id_parm))
return
# get the stream
stream = Stream.get_by_id(stream_id)
if stream is None:
fh.bad_request_error(self, response, 'Invalid Stream ID')
return
# write some stream info
response[fh.stream_name_parm] = stream.name
response[fh.owner_parm] = stream.get_owner_from_db().nickName
response[fh.num_images_parm] = len(stream.items)
# get the indices
ind1, ind2, status = fh.get_image_range_param(self)
if ind1 is None or ind2 is None:
fh.bad_request_error(self, response, status)
return
# query for images
items, in1, ind2 = stream.get_items(ind1, ind2)
image_urls = [item.URL for item in items]
if len(image_urls) == 0:
response[fh.image_range_parm] = None
else:
response[fh.image_range_parm] = "{0}-{1}".format(ind1, ind2)
# get the tags
stream_tags = StreamTag.get_batch_by_stream(stream)
response[fh.tags_parm] = [t.get_tag_name() for t in stream_tags]
#get lat/lng data for GeoMap
item_loc = []
for item in items:
if item.getLatLng() is not None:
oneItem = []
oneItem.append(item.stream.id())
oneItem.append(item.dateAdded.strftime("%Y-%m-%d %H:%M:%S"))
if item.URL is None:
imageURL = fh.get_file_url(item.blobKey)
else:
imageURL = item.URL
oneItem.append(imageURL)
oneItem.append(item.latitude)
oneItem.append(item.longitude)
item_loc.append(oneItem)
response['streamItemsLoc'] = item_loc
response['urls'] = image_urls
self.write_response(json.dumps(response))