def post(self, request, *args, **kwargs):
form = ClipForm(request.POST, request.FILES)
if form.is_valid:
newclip = Clip(video=request.FILES['file'],
name=request.POST['filename'])
newclip.save_clip()
return HttpResponse(status=201)
def get(self, request, clip_id=None):
if not clip_id:
clips = Clip.get_all_clips()
data = serializers.serialize('json', clips)
return HttpResponse(data, content_type='application/json')
clip = Clip.get_clip(clip_id)
data = serializers.serialize('json', clip)
return HttpResponse(data, content_type='application/json')
def get(self, request, clip_id=None):
if not clip_id:
clips = Clip.get_all_clips()
data = serializers.serialize('json', clips)
return HttpResponse(data, content_type='application/json')
clip = Clip.get_clip(clip_id)
data = serializers.serialize('json', clip)
return HttpResponse(data, content_type='application/json')
def put(self, request, clip_id):
data = json.loads(request.body)[0]
newname = data.get('fields', {}).get('name', None)
newdescription = data.get('fields', {}).get('description', None)
clip = Clip()
clip = clip.get_clip(clip_id)
form = ClipForm(clip)
if form.is_valid():
clip = Clip(name=newname,
description=newdescription,
pk=clip_id)
clip.save(update_fields=["name", "description"])
return HttpResponse(status=201)
def addclip(channel_id, show_id):
""" Add Clip route. Adds clip to whatever the current show that is being edited. """
error = None
form = NewClipForm()
if request.method == "POST" and form.validate_on_submit():
storage = GoogleStorage()
try:
current_show = Show.query.filter_by(
channel_id=channel_id, id=show_id).first()
fn = secure_filename(form.clip_file.data.filename)
# upload video to storage and save url
url = storage.upload_clip_video(name=secure_filename(
form.clip_file.data.filename), file=form.clip_file.data)
# save vid and get still from it
form.clip_file.data.save('/tmp/{}'.format(fn))
image_path = screencap_from_video("/tmp/{}".format(fn))
still_url = storage.upload_clip_image(
name=image_path.split("/")[-1], image_data=open(image_path).read())
current_show.clips.append(Clip(
name=form.clip_name.data,
description=form.description.data,
clip_url=url,
image_url=still_url,
))
db.session.commit()
except IntegrityError as e:
db.session.rollback()
if 'duplicate key value violates unique constraint' in str(e):
error = 'show name already registered.'
flash("Clip Created.", category="success")
return render_template("admin/addclip.html", form=form, error=error)
def delete(self, request, clip_id):
clip = Clip.get_clip(clip_id)
data = serializers.serialize('json', clip).encode('utf-8')
# convert to dict
data = json.loads(data)[0]
# get current clip url
url = data.get('fields', {}).get('url', None)
# delete file on amazon
delete_from_amazon_with_boto(url)
clip.delete()
return HttpResponse(status=201)
def delete(self, request, clip_id):
clip = Clip.get_clip(clip_id)
data = serializers.serialize('json', clip).encode('utf-8')
# convert to dict
data = json.loads(data)[0]
# get current clip url
url = data.get('fields', {}).get('url', None)
# delete file on amazon
delete_from_amazon_with_boto(url)
clip.delete()
return HttpResponse(status=201)
def process_dream(dream_slug, configs):
''' pull important words from a dream's description
then find relevant clips for each keyword
having an annoying issue getting connected to mongo in this file..
thus the silly passing of the mongo config data
'''
# connect to mongo
connect(configs['mongo']['db_name'], host=configs['mongo']['host']
, port=int(configs['mongo']['port']))
dreams = Dream.objects(slug=dream_slug)
dream = dreams[0]
keywords = _find_keywords(dream.description)
groups = _find_keyword_groups(dream.description, keywords)
# limit to ten keywords and ten groups
keywords = keywords[0:10]
keyword_groups = groups[0:10]
dream.update(set__keywords = keywords)
dream.update(set__keyword_groups = keyword_groups)
# preallocate the array of clips
clips = []
#for word in keywords:
for word in keyword_groups:
new_clip = Clip(
keyword = word
, mp4_url = ''
)
new_clip.save()
clips.append(new_clip)
dream.update(set__clips = clips)
#for index, word in enumerate(keywords):
for index, word in enumerate(keyword_groups):
queue.enqueue_call(
func=append_clip
, args=(word, index, dream, clips[index], configs,)
, timeout=300
)
def post_clip(user):
data = json.loads(request.data)
id = data['id']
place = Place.query.filter_by(id=id).first()
if place is None:
place = build_place(id)
clip = Clip(user=user)
place.clips.append(clip)
# TODO: set count(clips) + 1
place.clipped_count += 1
db.session.add(place)
db.session.commit()
return jsonify({'message': 'success to save'})
def getClipById(self, id):
try:
data = self.getOneElementById('clips', id)
if data:
print("Successfully retrieved clip")
from models import Clip
return Clip(*data, self)
else:
print("Failed to retrieve clip: no clip")
return None
except:
print("Failed to retrieve clip: no connection", sys.exc_info()[1])
return None
def getAllClips(self):
conn = psycopg2.connect(self.URL, sslmode=self.SSL)
cur = conn.cursor()
cur.execute("SELECT * FROM clips")
data = cur.fetchall()
cur.close()
conn.close()
clips = []
from models import Clip
for c in data:
print(len(c))
clips.append(Clip(*c, self))
return clips
def put(self, request, clip_id):
data = json.loads(request.body)[0]
newname = data.get('fields', {}).get('name', None)
newdescription = data.get('fields', {}).get('description', None)
clip = Clip()
clip = clip.get_clip(clip_id)
form = ClipForm(clip)
if form.is_valid():
clip = Clip(name=newname, description=newdescription, pk=clip_id)
clip.save(update_fields=["name", "description"])
return HttpResponse(status=201)
def post(self, request):
form = ClipForm(request.POST, request.FILES)
if form.is_valid:
newclip = Clip(
name=request.POST['filename'],
description=request.POST['description'],
)
clipfile = request.FILES['file']
newclip.url = save_on_amazon_with_boto(clipfile)
newclip.mimetype = newclip.generate_mimetype(newclip.url)
newclip.save()
return HttpResponse(status=201)
def getRandomClip(self):
try:
conn = psycopg2.connect(self.URL, sslmode=self.SSL)
cur = conn.cursor()
cur.execute(
"SELECT * FROM Clips OFFSET floor(random() * (SELECT COUNT(*) FROM Clips) ) LIMIT 1;"
)
data = cur.fetchone()
if data:
print("Successfully retrieved RANDOM clip")
from models import Clip
return Clip(*data, self)
else:
print("Failed to retrieve RANDOM clip: no clip")
return None
cur.close()
conn.close()
except:
print("Failed to retrieve RANDOM clip: no connection",
sys.exc_info()[1])
return None
def post(self, request):
form = ClipForm(request.POST, request.FILES)
if form.is_valid:
newclip = Clip(name=request.POST['filename'],
description=request.POST['description'],
)
clipfile = request.FILES['file']
newclip.url = save_on_amazon_with_boto(clipfile)
newclip.mimetype = newclip.generate_mimetype(newclip.url)
newclip.save()
return HttpResponse(status=201)
def armchair_tourist_witw_feed():
""">model
Downloads and uploads the beaches feed from ArmchairTourist to our db.
"""
g = GoogleStorage()
feed_url = "http://www.armchairtourist.com/feed/feed.php"
r = requests.get(feed_url)
r.raise_for_status()
show = db.session.query(Show).filter(
Show.name == "Where in the World?").first()
existing_clips = {
clip.name: clip
for clip in db.session.query(Clip).filter(
Clip.show_id == show.id).all()
}
# Iterate each entry in the feed.
for entry in r.json()["shortFormVideos"]:
# Only continue if the entry does not exist as a clip already.
if not existing_clips.get(entry["title"]):
# Download thumbnail.
image_req = requests.get(entry["thumbnail"], stream=True)
image_url = None
image_extension = None
try:
image_extension = entry["thumbnail"].split("/")[-1].split(
".")[-1]
except Exception as err:
print(err)
image_filename = entry["title"] + ".{}".format(image_extension)
image_path = "/tmp/{}".format(image_filename)
if image_req.ok:
with open(image_path, 'wb') as f:
for chunk in image_req:
if chunk:
f.write(chunk)
f.flush()
resize_image(image_path)
image_url = g.upload_clip_image(
entry["title"] + ".{}".format(image_extension),
open(image_path).read())
# Download video.
vid_url = entry["content"]["videos"][0]["url"]
video_req = requests.get(vid_url, stream=True)
if video_req.ok:
file_extension = None
try:
file_extension = vid_url.split("/")[-1].split(".")[-1]
except Exception as err:
print(err)
if not file_extension:
file_extension = ".mp4"
file_path = "/tmp/{}.{}".format(entry["title"], file_extension)
with open(file_path, 'wb') as f:
for chunk in video_req.iter_content(chunk_size=1024):
if chunk:
f.write(chunk)
f.flush()
# Upload clip video to google storage.
video_url = g.upload_clip_video(
entry["title"] + ".{}".format(file_extension),
open(file_path))
# We have downloaded/uploaded everything so now add to DB.
new_clip = Clip()
new_clip.name = entry["title"]
new_clip.description = entry["shortDescription"]
new_clip.duration = entry["content"]["duration"]
new_clip.clip_url = video_url
new_clip.image_url = image_url
show.clips.append(new_clip)
existing_clips[new_clip.name] = new_clip
print("Added clip", new_clip.name)
db.session.commit()
def delete(self, request, pk):
clip = Clip()
clip.delete_clip(pk)
return HttpResponse(status=201)