def post(self):
stream = Stream(parent=streambook_key())
user = users.get_current_user()
if user:
stream.author = Author(identity=user.user_id(), email=user.email())
stream_name = self.request.get('streamname').strip()
if not stream_name:
self.redirect('/management')
return
streams = Stream.query(
Stream.name == stream_name,
ancestor=streambook_key()) \
.fetch()
if streams:
self.redirect('/social')
return
stream.name = stream_name
stream.num_of_views = 0
stream.num_of_imgs = 0
subscriber = self.request.get('subscriber')
if subscriber:
stream.subscriber = subscriber.split(',')
if user.email() in stream.subscriber:
stream.subscriber.remove(user.email())
else:
stream.subscriber = []
stream.invite_msg = self.request.get('message')
stream.tag = self.request.get('tag').split(',')
stream.cover_img = self.request.get('urlcover')
if not stream.cover_img:
stream.cover_img = "img/no_image_available.png"
for sub in stream.subscriber:
message = mail.EmailMessage()
message.to = sub
message.body = """
%s invites you to subscribe Stream:%s
From %s: %s
""" % (stream.author.email, stream.name, stream.author.email,
stream.invite_msg)
message.sender = stream.author.email
message.subject = "Invitation Email from miniproject-js.appspot.com"
message.send()
stream.put()
self.redirect('/management')
def get(self):
stream_name = self.request.get("name")
stream = Stream.query(
Stream.name == stream_name,
ancestor=streambook_key()) \
.fetch()
if stream:
stream = stream[0]
imgs = Photo.query(
ancestor=stream.key) \
.order(-Photo.date) \
.fetch()
stream.num_of_views += 1
stream.view_dates.append(datetime.datetime.now())
stream.put()
img_urls = [images.get_serving_url(img.img_key) for img in imgs]
img_caps = [img.name for img in imgs]
data = {
'ImageList': img_urls,
'ImageCaptionList': img_caps,
'UserEmail': stream.author.email
}
json_data = json.dumps(data)
self.response.write(json_data)
def handle_upload(self):
results = []
stream_name = self.request.get('name')
stream = Stream.query(
Stream.name == stream_name,
ancestor=streambook_key()) \
.fetch()[0]
img_name = self.request.get('photoCaption')
img_lat = float(self.request.get('location[latitude]'))
img_long = float(self.request.get('location[longitude]'))
img_upload = self.get_uploads()[0]
result = {
'name': img_name,
'type': img_upload.content_type,
'size': img_upload.size
}
logging.debug("name = %s, type = %s, size = %d , lat = %f, long = %f" %
(result['name'], result['type'], result['size'], img_lat,
img_long))
if self.validate(result):
img_key = img_upload.key()
img_date = datetime.datetime.now()
img_entity_key = ndb.Key(Photo, img_name, parent=stream.key)
img = Photo(key=img_entity_key,
name=img_name,
date=img_date,
lat=img_lat,
long=img_long,
img_key=img_key)
img.put()
results.append(result)
return results
def get(self):
all_streams = Stream.query(
ancestor=streambook_key()) \
.order(-Stream.date) \
.fetch()
streams = []
search_tag = self.request.get("search_tag")
if search_tag:
for stream in all_streams:
if search_tag in stream.name:
streams.append(stream)
else:
for tag in stream.tag:
if search_tag in tag:
streams.append(stream)
break
stream_names = [stream.name for stream in streams]
cover_img_urls = [stream.cover_img for stream in streams]
data = {
'CoverImageList': cover_img_urls,
'StreamNameList': stream_names
}
json_data = json.dumps(data)
self.response.write(json_data)
def get(self):
user = users.get_current_user()
if not user:
self.redirect('/')
return
env = Environment(loader=FileSystemLoader(
os.path.join(os.path.dirname(__file__), 'templates')))
template = env.get_template('search.html')
all_streams = Stream.query(
ancestor=streambook_key()) \
.order(-Stream.date) \
.fetch()
keywords = []
for stream in all_streams:
keywords.append(stream.name)
for tags in stream.tag:
if tags not in keywords:
keywords.append(tags)
Search.initial = True
init = {'initial': Search.initial, 'keywords': json.dumps(keywords)}
self.response.write(template.render(init))
def get(self):
user = users.get_current_user()
if not user:
self.redirect('/')
return
env = Environment(loader=FileSystemLoader(os.path.join(os.path.dirname(__file__), 'templates')))
template = env.get_template('management.html')
streams = Stream.query(
Stream.author.identity == user.user_id(),
ancestor=streambook_key()) \
.order(-Stream.date) \
.fetch()
all_streams = Stream.query(
ancestor=streambook_key()) \
.order(-Stream.date) \
.fetch()
for stream in streams:
imgs = Photo.query(
ancestor=stream.key) \
.order(-Photo.date) \
.fetch()
if imgs:
stream.last_img_date = imgs[0].date
stream.num_of_imgs = len(imgs)
stream.put()
sub_streams = []
for stream in all_streams:
if user.email() in stream.subscriber:
sub_streams.append(stream)
management_values = {
'streams': streams,
'sub_streams': sub_streams,
}
self.response.write(template.render(management_values))
def post(self):
user = users.get_current_user()
streams = Stream.query(
ancestor=streambook_key()) \
.fetch()
for stream in streams:
if self.request.get(stream.name) == 'on':
stream.subscriber.remove(user.email())
stream.put()
self.redirect('/management')
def post(self):
env = Environment(loader=FileSystemLoader(
os.path.join(os.path.dirname(__file__), 'templates')))
template = env.get_template('search.html')
all_streams = Stream.query(
ancestor=streambook_key()) \
.order(-Stream.date) \
.fetch()
Search.found = False
Search.initial = False
streams = []
keywords = []
for stream in all_streams:
keywords.append(stream.name)
for tags in stream.tag:
if tags not in keywords:
keywords.append(tags)
Search.search_tag = self.request.get("tagsforsearch")
for stream in all_streams:
if Search.search_tag in stream.name:
streams.append(stream)
Search.found = True
else:
for tag in stream.tag:
if Search.search_tag in tag:
streams.append(stream)
Search.found = True
break
num_stream = len(streams)
if Search.search_tag == "":
Search.found = False
num_stream = 0
stream_found = {
'found': Search.found,
'initial': Search.initial,
'streams': streams,
'num_stream': num_stream,
'search_tags': Search.search_tag,
'keywords': json.dumps(keywords)
}
self.response.write(template.render(stream_found))
def post(self):
json_str = self.request.body
json_obj = json.loads(json_str)
stream_name = json_obj['name']
user_email = users.get_current_user().email()
stream = Stream.query(
Stream.name == stream_name,
ancestor=streambook_key()) \
.fetch()
if stream:
stream = stream[0]
if user_email in stream.subscriber:
stream.subscriber.remove(user_email)
stream.put()
def get(self):
streams = Stream.query(
ancestor=streambook_key()) \
.order(Stream.date) \
.fetch()
stream_names = [stream.name for stream in streams]
cover_img_urls = [stream.cover_img for stream in streams]
data = {
'CoverImageList': cover_img_urls,
'StreamNameList': stream_names
}
json_data = json.dumps(data)
self.response.write(json_data)
def post(self):
user = users.get_current_user()
streams = Stream.query(
Stream.author.identity == user.user_id(),
ancestor=streambook_key()) \
.fetch()
for stream in streams:
if self.request.get(stream.name) == 'on':
imgs = Photo.query(
ancestor=stream.key) \
.fetch()
for img in imgs:
blobstore.delete(img.img_key)
img.key.delete()
stream.key.delete()
self.redirect('/management')
def handle_upload(self):
results = []
stream_name = self.request.get('name')
stream = Stream.query(
Stream.name == stream_name,
ancestor=streambook_key()) \
.fetch()[0]
for img_upload in self.get_uploads():
result = {
'name': urllib.unquote(img_upload.filename),
'type': img_upload.content_type,
'size': img_upload.size
}
if self.validate(result):
self.write_data(stream, img_upload)
results.append(result)
return results
def get(self):
user = users.get_current_user()
if not user:
self.redirect('/')
return
env = Environment(loader=FileSystemLoader(
os.path.join(os.path.dirname(__file__), 'templates')))
template = env.get_template('view.html')
streams = Stream.query(
ancestor=streambook_key()) \
.order(Stream.date) \
.fetch()
all_stream = {
'streams': streams,
}
self.response.write(template.render(all_stream))
def get(self):
user_email = self.request.get("email")
all_streams = Stream.query(
ancestor=streambook_key()) \
.order(-Stream.date) \
.fetch()
sub_streams = []
for stream in all_streams:
if user_email in stream.subscriber:
sub_streams.append(stream)
stream_names = [stream.name for stream in sub_streams]
cover_img_urls = [stream.cover_img for stream in sub_streams]
data = {
'CoverImageList': cover_img_urls,
'StreamNameList': stream_names
}
json_data = json.dumps(data)
self.response.write(json_data)
def get(self):
user = users.get_current_user()
if not user:
self.redirect('/')
return
env = Environment(loader=FileSystemLoader(
os.path.join(os.path.dirname(__file__), 'templates')))
template = env.get_template('trending.html')
streams = Stream.query(
ancestor=streambook_key()) \
.order(-Stream.date) \
.fetch()
firststream = Stream(parent=streambook_key())
secondstream = Stream(parent=streambook_key())
thirdstream = Stream(parent=streambook_key())
del Trend.info[:]
for stream in streams:
# self.response.write(stream.name)
temp_num_views = 0
present = datetime.datetime.now()
# last_view_time = stream.view_dates[:-1]
for time in stream.view_dates:
time_diff = present - time
if time_diff.days == 0:
if time_diff.seconds <= 3600:
temp_num_views = temp_num_views + 1
else:
stream.view_dates.remove(time)
else:
stream.view_dates.remove(time)
stream.put()
if temp_num_views >= len(firststream.view_dates):
thirdstream = secondstream
secondstream = firststream
firststream = stream
elif temp_num_views >= len(secondstream.view_dates):
thirdstream = secondstream
secondstream = stream
elif temp_num_views >= len(thirdstream.view_dates):
thirdstream = stream
# self.response.write(stream.view_dates)
if len(streams) >= 3:
top3 = {
'firststream': firststream,
'secondstream': secondstream,
'thirdstream': thirdstream,
'num_stream': 3,
'highlight': Trend.highlight
}
f_tuple = (firststream.name, len(firststream.view_dates))
s_tuple = (secondstream.name, len(secondstream.view_dates))
t_tuple = (thirdstream.name, len(thirdstream.view_dates))
Trend.info.append(f_tuple)
Trend.info.append(s_tuple)
Trend.info.append(t_tuple)
self.response.write(template.render(top3))
elif len(streams) >= 2:
top3 = {
'firststream': firststream,
'secondstream': secondstream,
'num_stream': 2,
'highlight': Trend.highlight
}
f_tuple = (firststream.name, len(firststream.view_dates))
s_tuple = (secondstream.name, len(secondstream.view_dates))
Trend.info.append(f_tuple)
Trend.info.append(s_tuple)
self.response.write(template.render(top3))
elif len(streams) >= 1:
top3 = {
'firststream': firststream,
'num_stream': 1,
'highlight': Trend.highlight
}
f_tuple = (firststream.name, len(firststream.view_dates))
Trend.info.append(f_tuple)
self.response.write(template.render(top3))
else:
top3 = {'num_stream': 0, 'highlight': Trend.highlight}
self.response.write(template.render(top3))
def get(self):
try:
user = users.get_current_user()
if not user:
self.redirect('/')
return
env = Environment(loader=FileSystemLoader(
os.path.join(os.path.dirname(__file__), 'templates')))
template = env.get_template('stream.html')
stream_name = self.request.get("name")
stream = Stream.query(
Stream.name == stream_name,
ancestor=streambook_key()) \
.fetch()
if stream:
stream = stream[0]
image_id = self.request.get("id")
if image_id:
image_id = int(image_id)
else:
image_id = 0
more_images = True
imgs = Photo.query(
ancestor=stream.key) \
.order(-Photo.date) \
.fetch()
num_image = len(imgs)
if num_image > 3:
last_id = num_image
if last_id > image_id + 3:
imgs = imgs[image_id:image_id + 3]
else:
imgs = imgs[image_id:last_id]
more_images = False
subscribed = False
user_id = user.user_id()
user_email = user.email()
if user_id == stream.author.identity:
user_true = True
else:
user_true = False
if user_email in stream.subscriber:
subscribed = True
if ViewStream.not_view == 0:
stream.num_of_views += 1
stream.view_dates.append(datetime.datetime.now())
else:
ViewStream.not_view = 0
stream.put()
img_thumburls = [
images.get_serving_url(img.img_key) for img in imgs
]
img_urls = [img_url + '=s0' for img_url in img_thumburls]
img_with_urls = zip(imgs, img_urls, img_thumburls)
view_stream = {
'id': image_id,
'imgs': img_with_urls,
'stream': stream,
'num_image': num_image,
'more_images': more_images,
'user_true': user_true,
'subscribed': subscribed,
}
self.response.write(template.render(view_stream))
except:
self.redirect('/social')
def get(self):
if RebuildIndex.be_click == 1:
if Search.initial == True:
env = Environment(loader=FileSystemLoader(
os.path.join(os.path.dirname(__file__), 'templates')))
template = env.get_template('search.html')
all_streams = Stream.query(
ancestor=streambook_key()) \
.order(-Stream.date) \
.fetch()
keywords = []
for stream in all_streams:
keywords.append(stream.name)
for tags in stream.tag:
if tags not in keywords:
keywords.append(tags)
init = {
'initial': Search.initial,
'keywords': json.dumps(keywords)
}
# self.response.write('cron works')
self.response.write(template.render(init))
elif Search.initial == False:
env = Environment(loader=FileSystemLoader(
os.path.join(os.path.dirname(__file__), 'templates')))
template = env.get_template('search.html')
all_streams = Stream.query(
ancestor=streambook_key()) \
.order(-Stream.date) \
.fetch()
streams = []
keywords = []
for stream in all_streams:
keywords.append(stream.name)
for tags in stream.tag:
if tags not in keywords:
keywords.append(tags)
for stream in all_streams:
if Search.search_tag in stream.name:
streams.append(stream)
Search.found = True
else:
for tag in stream.tag:
if Search.search_tag in tag:
streams.append(stream)
Search.found = True
break
num_stream = len(streams)
stream_found = {
'found': Search.found,
'initial': Search.initial,
'streams': streams,
'num_stream': num_stream,
'search_tags': Search.search_tag,
'keywords': json.dumps(keywords)
}
self.response.write(template.render(stream_found))
