def get_movies_list():
movies = Movie.query()
data = []
for movie in movies:
item = movie.to_dict()
item["id"] = movie.key.id()
data.append(item)
return {"error": False, "data": data}
def movie_add():
form = MovieForm()
if form.validate_on_submit():
data = form.data
#提交的片名在数据库中已存在
if Movie.query.filter_by(title=data['title']).count() == 1:
flash('电影片名已存在,请检查', category='err')
return redirect(url_for('admin.movie_add'))
#获取上传文件的名称
file_url = secure_filename(form.url.data.filename)
file_logo = secure_filename(form.logo.data.filename)
#文件保存路径操作
file_save_path = app.config['UP_DIR'] #文件上传保存路径
if not os.path.exists(file_save_path):
os.makedirs(file_save_path) #如果文件保存路径不存在,则创建一个多级目录
import stat
os.chmod(file_save_path, stat.S_IRWXU) #授予可读写权限
#对上传的文件进行重命名
url = change_filename(file_url)
logo = change_filename(file_logo)
#保存文件,需要给文件的保存路径+文件名
form.url.data.save(file_save_path + url)
form.logo.data.save(file_save_path + logo)
movie = Movie(title=data['title'],
url=url,
info=data['info'],
logo=logo,
star=data['star'],
play_num=0,
comment_num=0,
tag_id=data['tag_id'],
area=data['area'],
release_time=data['release_time'],
length=data['length'])
db.session.add(movie)
db.session.commit()
flash('添加电影成功', 'ok')
return redirect(url_for('admin.movie_add'))
return render_template('admin/movie_add.html', form=form)
def movie_add():
"""
添加电影
"""
form = MovieForm()
form.tag_id.choices = [(v.id, v.name) for v in Tag.query.all()]
if form.validate_on_submit():
data = form.data
file_url = secure_filename(form.url.data.filename)
file_logo = secure_filename(form.logo.data.filename)
# 保存路径是否存在
if not os.path.exists(app.config['UP_DIR']):
os.makedirs(app.config['UP_DIR'])
os.chmod(app.config['UP_DIR'], stat.S_IRWXU)
# 生成唯一文件名
url = change_filename(file_url)
logo = change_filename(file_logo)
# 保存文件
form.url.data.save(app.config['UP_DIR'] + url)
form.logo.data.save(app.config['UP_DIR'] + logo)
# 构造电影实体，存入数据库
movie = Movie(title=data['title'],
url=url,
info=data['info'],
logo=logo,
star=int(data['star']),
play_num=0,
comment_num=0,
tag_id=int(data['tag_id']),
area=data['area'],
release_time=data['release_time'],
length=data['length'])
db.session.add(movie)
db.session.commit()
flash('添加电影成功', 'success')
return redirect(url_for('admin.movie_add'))
return render_template('admin/movie_add.html', form=form)
def upload_movie():
form = MovieForm()
form.tag.choices = [(t.id, t.name) for t in Tag.query.all()]
print(form.validate_on_submit())
if form.validate_on_submit():
tags = [Tag.query.get_or_404(id) for id in form.tag.data]
movie = Movie(name=form.name.data,
info=form.desc.data,
poster=form.poster.data,
url=form.source.data,
region=form.country.data,
length=form.length.data,
time_release=form.release.data,
tags=tags)
print(movie)
db.session.add(movie)
db.session.commit()
flash("Movie was upload", "success")
return redirect(url_for("admin_bp.index"))
return render_template("admin/upload_movie.html", form=form)
def get_movie(id):
get_movie_details_url = base_url.format(id, api_key)
with urllib.request.urlopen(get_movie_details_url) as url:
movie_details_data = url.read()
movie_details_response = json.loads(movie_details_data)
movie_object = None
if movie_details_response:
id = movie_details_response.get('id')
title = movie_details_response.get('original_title')
overview = movie_details_response.get('overview')
poster = movie_details_response.get('poster_path')
vote_average = movie_details_response.get('vote_average')
vote_count = movie_details_response.get('vote_count')
movie_object = Movie(id, title, overview, poster, vote_average,
vote_count)
return movie_object
def movie(tmdb_id):
mov = Movie.query.filter_by(tmdb_id=tmdb_id).first()
if mov is None:
data = tmdb.get_movie(tmdb_id)
if not data:
flash('Movie %s not found.' % tmdb_id)
return redirect('/')
mov = Movie(data)
imdb = 'http://www.dereferer.org/?' + urllib.parse.quote_plus(
'http://www.imdb.com/title/' + mov.imdb_id)
settings_form = QualityForm()
settings_form.quality.data = mov.search_quality
return render_template('movies/view.html',
title=mov.title,
heading=mov.title,
media=mov,
search_form=SearchForm(),
settings_form=settings_form,
imdb_link=imdb,
refreshing=Library.refreshing_movie(tmdb_id))
def handle_fomdata():
moviename = request.form['name']
movielength = Movie.query.filter_by(Name=moviename).count()
if movielength == 0:
moviedesc = request.form['desc']
movieposter = request.form['poster']
try:
f = open('app/static/poster/' + moviename + '.jpg', 'wb')
with urllib.request.urlopen(movieposter) as url:
s = url.read()
f.write(s)
f.close()
dbmovieposter = '/poster/' + moviename + '.jpg'
except:
dbmovieposter = ""
nmovie = Movie(moviename, moviedesc, dbmovieposter)
db.session.add(nmovie)
db.session.commit()
return "success"
def testGetMovie(self):
rv, u = self._fixture_get_token()
m = Movie(title='t', description='d')
db.session.add(m)
db.session.commit()
rv_watched = self.client.get('/api/movie/%d' % m.id,
headers={'Authorization': 'Bearer %s' % rv.get_json()['token']})
expected = {
'_links': {'self': 'http://localhost:5000/api/movie/1'},
'description': 'd',
'id': 1, 'imdbId': 0, 'tmdbId': 0, 'ytbeId': '0',
'rating': {'score': 0.0, 'support': 0},
'title': 't'
}
self.assertEqual(200, rv_watched.status_code)
self.assertEqual(expected, rv_watched.get_json())
def index():
form = MovieForm()
if request.method == 'POST':
if not current_user.is_authenticated:
flash('Please Login.')
return redirect(url_for('login'))
if form.validate_on_submit():
title = form.title.data
year = form.year.data
movie = Movie(title=title, year=year)
db.session.add(movie)
db.session.commit()
flash('Item created.')
return redirect(url_for('index'))
else:
flash('Invalid input.')
return redirect(url_for('index'))
movies = Movie.query.all()
return render_template('index.html', movies=movies, form=form)
def movie_add():
"""
编辑电影页面
"""
form = MovieForm()
if form.validate_on_submit():
data = form.data
file_url = secure_filename(form.url.data.filename)
file_logo = secure_filename(form.logo.data.filename)
if not os.path.exists(app.config["UP_DIR_MVLOGO"]):
# 创建一个多级目录
os.makedirs(app.config["UP_DIR_MVLOGO"])
os.chmod(app.config["UP_DIR_MVLOGO"], "rw")
if not os.path.exists(app.config["UP_DIR_MV"]):
# 创建一个多级目录，用于保存电影
os.makedirs(app.config["UP_DIR_MV"])
os.chmod(app.config["UP_DIR_MV"], "rw")
url = change_filename(file_url)
logo = change_filename(file_logo)
# 保存
form.url.data.save(app.config["UP_DIR_MV"] + url)
form.logo.data.save(app.config["UP_DIR_MVLOGO"] + logo)
# url,logo为上传视频,图片之后获取到的地址
movie = Movie(title=data["title"],
url=url,
info=data["info"],
logo=logo,
star=int(data["star"]),
playnum=0,
commentnum=0,
tag_id=int(data["tag_id"]),
area=data["area"],
release_time=data["release_time"],
length=data["length"])
db.session.add(movie)
db.session.commit()
flash("添加电影成功！", "ok")
return redirect(url_for('admin.movie_add'))
return render_template("admin/movie_add.html", form=form)
def movie_add():
form = MovieForm()
if form.validate_on_submit():
data = form.data
# file_url = secure_filename(''.join(lazy_pinyin(form.url.data.filename)))
# file_logo = secure_filename(''.join(lazy_pinyin(form.logo.data.filename)))
if not os.path.exists(app.config['MOVIE_DIR']):
os.makedirs(app.config['MOVIE_DIR'])
os.chmod(app.config['MOVIE_DIR'], 'rw')
if not os.path.exists(app.config['LOGO_DIR']):
os.makedirs(app.config['LOGO_DIR'])
os.chmod(app.config['LOGO_DIR'], 'rw')
# url = change_filename(file_url)
url = form.url.data.filename
# logo = change_filename(file_logo)
logo = form.logo.data.filename
form.url.data.save(app.config['MOVIE_DIR'] + url)
form.logo.data.save(app.config['LOGO_DIR'] + logo)
movie = Movie(
title=data['title'],
url=url,
info=data['info'],
logo=logo,
star=data['star'],
playnum=0,
commentnum=0,
tag_id=data["tag_id"],
area=data['area'],
length=data['length'],
release_time=data['release_time'],
)
db.session.add(movie)
db.session.commit()
flash('添加电影成功', 'ok')
oplog = Oplog(admin_id=session['admin_id'],
ip=request.remote_addr,
reason='添加一个电影：%s' % data['title'])
db.session.add(oplog)
db.session.commit()
return redirect(url_for('admin.movie_add'))
return render_template('admin/movie_add.html', form=form)
def movie_add():
'''
电影添加
'''
form = MovieForm()
if form.validate_on_submit():
print(request.files["url"].filename)
file_url = secure_filename(request.files["url"].filename)
file_logo = secure_filename(request.files["logo"].filename)
if not os.path.exists(app.config["UP_DIR"]):
os.makedirs(app.config["UP_DIR"])
os.chmod(app.config["UP_DIR"], 'rw')
url = change_filename(file_url)
logo = change_filename(file_logo)
form.url.data.save(app.config["UP_DIR"] + url)
form.logo.data.save(app.config["UP_DIR"] + logo)
movie = Movie(
title=form.title.data,
url=url,
info=form.info.data,
logo=logo,
star=int(form.star.data),
playnum=0,
commentnum=0,
tag_id=int(form.tag_id.data),
area=form.area.data,
release_time=form.release_time.data,
length=form.length.data,
)
db.session.add(movie)
db.session.commit()
# 将图片 视频上传到oss空间中
oss = Oss()
oss.putfile(url, app.config['UP_DIR'] + url)
oss.putfile(url, app.config['UP_DIR'] + logo)
print(url)
flash("添加电影成功！", "ok")
return redirect(url_for('admin.movie_list', page=1))
return render_template("admin/movie_add.html", form=form)
def movie_add():
form = MovieForm()
if form.validate_on_submit():
data = form.data
movie_count = Tag.query.filter_by(name=data['title']).count()
if movie_count >= 1:
flash('片名已存在', 'err')
return redirect(url_for('admin.movie_add'))
file_url = secure_filename(form.url.data.filename)
file_logo = secure_filename(form.logo.data.filename)
if not os.path.exists(app.config['UP_DIR']):
os.makedirs(app.config['UP_DIR']) # 创建目录
os.chmod(app.config['UP_DIR'], stat.S_IRWXU) # 授权可读写
url = change_filename(file_url)
logo = change_filename(file_logo)
form.url.data.save(app.config['UP_DIR'] + url)
form.url.data.save(app.config['UP_DIR'] + logo)
movie = Movie(
title=data['title'],
url=url,
info=data['info'],
logo=logo,
star=int(data['star']),
playnum=0,
commentnum=0,
tag_id=int(data['tag_id']),
area=data['area'],
release_time=data['release_time'],
length=data['length']
)
oplog = Oplog(
admin_id=session['admin_id'],
reason='添加电影：%s' % data['title'],
ip=request.remote_addr
)
db.session.add(movie)
db.session.add(oplog)
db.session.commit()
flash('添加电影成功', 'ok')
return redirect(url_for('admin.movie_add'))
return render_template("admin/movie_add.html", form=form)
def movie_add():
form = MovieForm()
if form.validate_on_submit():
data = form.data
if Movie.query.filter_by(title=data["title"]).count() == 1:
flash("影片已经存在！", "err")
return redirect(url_for("admin.movie_add"))
file_url = secure_filename(form.url.data.filename) # 获取并转化为安全的电影文件名
file_logo = secure_filename(form.logo.data.filename)
if not os.path.exists(app.config['UP_DIR']): # 存放目录不存在则创建
os.makedirs(app.config['UP_DIR'])
os.chmod(app.config['UP_DIR'], "rw")
url = change_filename(file_url) # 调用函数生成新的文件名
logo = change_filename(file_logo)
form.url.data.save(app.config['UP_DIR'] + url) # 保存上传的数据
form.logo.data.save(app.config['UP_DIR'] + logo)
admin_id = session["admin_id"]
logger.info("操作人id:{0}".format(admin_id))
movie = Movie(title=data["title"],
url=url,
info=data["info"],
logo=logo,
star=int(data["star"]),
playnum=0,
commentnum=0,
tag_id=int(data["tag_id"]),
area=data["area"],
release_time=data["release_time"],
length=data["length"],
creater_id=admin_id)
db.session.add(movie)
db.session.commit()
flash("添加电影成功！", "ok")
oplog = Oplog(admin_id=session["admin_id"],
ip=request.remote_addr,
reason="添加新电影：%s" % data["title"])
db.session.add(oplog)
db.session.commit()
return redirect(url_for("admin.movie_add"))
return render_template("admin/movie_add.html", form=form)
def test_post_movie_actors_cd(self):
'''Test post_actors as Casting Director '''
movie = Movie(title='Test Movie', release_date='2020-01-15')
movie.insert()
actor = Actor(name='Test Actor', age=40, gender='M')
actor.insert()
res = self.client().post(f'/movies/{movie.id}/actors',
json={'actor': {
'id': actor.id
}},
headers={'Authorization': bearer('cd')})
self.assertEqual(res.status_code, 200)
self.assertIsInstance(res.json["movie"], dict)
actor.delete()
movie.delete()
def add_movies(movies):
for m in movies:
movie = Movie(m["id"], m["title"], m["overview"], m["adult"],
m["poster_path"], m["runtime"], m["release_date"],
m["original_language"], m["vote_average"])
for c in m["credits"]["cast"]:
character_name = c["character"]
if c["order"] > 20:
continue
character = get_character(character_name)
if (character):
movie.characters.append(character)
actor_id = c["id"]
actor = Actor.query.filter_by(id=actor_id).first()
if actor:
movie.actors.append(actor)
if actor and character:
actor.characters.append(character)
db.session.merge(movie)
db.session.commit()
print("Added " + m["title"])
def get_movie(tmdb_id):
"""
Get movie details from TMDB, store them in Movie model.
Params: tmdb_id - The TMDB ID of the movie
Returns: Movie object if tmdb_id is valid
None otherwise
"""
url = BASE_URL.format(api_endpoint='movie/' + str(tmdb_id))
details = requests.get(url).json()
# todo: handle errors from TMDB
release_date = details.get('release_date')
release_date = datetime.datetime.strptime(release_date, '%Y-%m-%d')
movie = Movie(tmdb_id=tmdb_id,
title=details.get('title'),
release_date=release_date)
return movie
def get(self, request, pk):
user = User.get_user(request.user)
movie = Movie.get_or_create(pk)
if movie is None:
raise Http404
try:
collected_item = CollectedMovie.objects.filter(user=user, movie=movie).get()
collected_item.type = self.list_type
except CollectedMovie.DoesNotExist:
collected_item = CollectedMovie(
user=user,
movie=movie,
type=self.list_type
)
collected_item.save()
# success status
return Response('')
def scan_folders():
"""Scans video folders for video files, converts new videos and adds them to DB"""
movies = []
# Check for mp4, mkv, avi files in video folder
fileset = formic.FileSet(include=["*.mp4", "*.mkv", "*.avi"],
directory=VIDEO_FOLDER)
# Loop found files
for file_name in fileset.files():
file_name = os.path.join(fileset.get_directory(), file_name[1])
# Return relative path of found files
rec_name = file_name.replace(VIDEO_FOLDER, '')
rel_name = rec_name
rec_name = rec_name.replace('.avi', '.mp4')
# See if path found in database, if not: continue
if Movie.query.filter_by(url=rec_name).first() is None:
# or Movie.query.filter_by(url = rec_name).first() < 1:
# Check if filesize is different after 5 second, aka not completely uploaded yet
size = os.path.getsize(file_name)
time.sleep(5)
if size == os.path.getsize(file_name):
# Generate subtitle path from movie path
# FIXME: Not needed anymore I guess
subsrt = rec_name.replace('.mp4', '.srt')
subsrt = subsrt.replace('.avi', '.srt')
subsrt = subsrt.replace('.mkv', '.srt')
# Get extension and add movie to database as IN_PROGRESS
extension = os.path.splitext(rel_name)[1]
dbextension = os.path.splitext(rec_name)[1]
newmovie = Movie(url=rec_name, srt=subsrt, type=dbextension)
db.session.add(newmovie)
db.session.commit()
# Fetch subtitles automatically
get_subtitle(newmovie.id, file_name)
# Check if needs converting or can just call done
if extension == '.mp4':
complete(newmovie.id)
elif extension == '.avi':
convert_mp4(newmovie.id, file_name)
elif extension == '.mkv':
complete(newmovie.id)
def new_movie():
title = request.forms.get("title")
year = request.forms.get("year")
runtime = request.forms.get("runtime")
category = request.forms.get("category")
comment = request.forms.get("comment")
poster = request.files.get("poster")
if title is not None and year is not None and runtime is not None and category is not None and poster is not None:
try:
movie = Movie()
movie.title = title
movie.year = int(year)
movie.runtime = int(runtime)
movie.category = category
movie.comment = comment
movie.poster = db.Blob(poster)
movie_key = movie.put()
except Exception, e:
return e
def movie_add():
"""添加电影"""
form = MovieForm()
if form.validate_on_submit():
data = form.data
file_url = secure_filename(form.url.data.filename)
file_logo = secure_filename(form.logo.data.filename)
if not os.path.exists(app.config["UP_DIR"]):
# 创建一个多级目录
os.makedirs(app.config["UP_DIR"])
os.chmod(app.config["UP_DIR"], "rw")
# url,logo为上传视频,图片之后得到的地址
url = change_filename(file_url)
logo = change_filename(file_logo)
# 保存url和logo
form.url.data.save(app.config["UP_DIR"] + url)
form.logo.data.save(app.config["UP_DIR"] + logo)
movie_count = Movie.query.filter_by(title=data["title"]).count()
# 已存在该上映预告
if movie_count == 1:
flash("片名已经存在，请重新编辑！", "err")
return redirect(url_for('admin.movie_add'))
movie = Movie(
title=data['title'],
url=url,
info=data['info'],
logo=logo,
star=int(data['star']),
playnum=0,
commentnum=0,
tag_id=(data['tag_id']),
area=data['area'],
release_time=data['release_time'],
length=data['length'],
)
db.session.add(movie)
db.session.commit()
flash("添加电影成功！", "ok")
return redirect(url_for('admin.movie_add'))
return render_template('admin/movie_add.html', form=form)
def movie_add():
form = MovieForm()
if form.validate_on_submit():
data = form.data
file_url = secure_filename(form.url.data.filename)
file_logo = secure_filename(form.logo.data.filename)
if not os.path.exists(app.config["UP_DIR"]):
os.makedirs(app.config["UP_DIR"])
os.chmod(app.config["UP_DIR"], stat.S_IRWXU)
url = change_filename(file_url)
logo = change_filename(file_logo)
form.url.data.save(app.config["UP_DIR"] + url)
form.logo.data.save(app.config["UP_DIR"] + logo)
movie = Movie(
title=data["title"],
url=url,
info=data["info"],
logo=logo,
star=int(data["star"]),
playnum=0,
commentnum=0,
tag_id=int(data["tag_id"]),
area=data["area"],
release_time=data["release_time"],
length=data["length"],
)
db.session.add(movie)
oplog = OpLog(
admin_id=session["admin_id"],
ip=request.remote_addr,
reason='添加电影"{0}"'.format(movie.title),
)
db.session.add(oplog)
db.session.commit()
flash('电影"{0}"添加成功!'.format(data["title"]), "ok")
return redirect(url_for("admin.movie_add"))
return render_template("admin/movie_add.html", form=form)
def test_patch_movies_cd(self):
'''Test patch_movies as Casting Director '''
movie = Movie(title='Test Movie', release_date='2020-01-15')
movie.insert()
res = self.client().patch(f'/movies/{movie.id}',
json={
'title': 'Test Movieeee',
'release_date': '1920-01-15'
},
headers={'Authorization': bearer('cd')})
self.assertEqual(res.status_code, 200)
self.assertIsInstance(res.json['movie'], dict)
movie = Movie.query.get(movie.id)
self.assertEqual(movie.title, 'Test Movieeee')
self.assertEqual(movie.release_date, '1920-01-15')
movie.delete()
def movie_add():
form = MovieForm()
if form.validate_on_submit():
data = form.data
title = Movie.query.filter_by(title=data['title']).count()
if title != 0:
flash('电影名称已经存在', 'err')
return redirect(url_for('admin.movie_add'))
elif form.url.data == '' or form.logo.data == '':
flash('文件或封面不能为空', 'err')
return redirect(url_for('admin.movie_add'))
else:
file_url = secure_filename(form.url.data.filename)
file_logo = secure_filename(form.logo.data.filename)
if not os.path.exists(app.config['UP_DIR']):
os.makedirs(app.config['UP_DIR'])
os.chmod(app.config['UP_DIR'], 'rw')
url = change_filename(file_url)
logo = change_filename(file_logo)
form.url.data.save(app.config['UP_DIR'] + url)
form.logo.data.save(app.config['UP_DIR'] + logo)
movie = Movie(
title=data['title'],
url=url,
info=data['info'],
logo=logo,
star=int(data['star']),
playnum=0,
commentnum=0,
tag_id=int(data['tag_id']),
area=data['area'],
release_time=data['release_time'],
length=data['length'],
)
db.session.add(movie)
db.session.commit()
flash('添加电影成功', 'ok')
return redirect(url_for('admin.movie_add'))
return render_template('admin/movie_add.html', form=form)
def index():
if request.method == 'POST':
if not current_user.is_authenticated:
return redirect(url_for('home.index'))
title = request.form.get('title')
year = request.form.get('year')
if not title or not year or len(year) > 4 or len(title) > 60:
flash('Invalid input.')
return redirect(url_for('home.index'))
movie = Movie(title=title, year=year)
db.session.add(movie)
db.session.commit()
flash('Item created.')
return redirect(url_for('home.index'))
user = User.query.first()
movies = Movie.query.all()
return render_template('index.html', user=user, movies=movies)
def movie_add():
form = MovieFrom()
form.tag_id.choices = [(v.id, v.name) for v in Tag.query.all()] # 更新标签列表
form.logo.validators = [DataRequired("请上传封面！")]
form.url.validators = [DataRequired("请上传文件！")]
if form.validate_on_submit():
data = form.data
movie_count = Movie.query.filter_by(title=data['title']).count()
if movie_count == 1:
flash("片名已经存在，出现冲突", "err")
return redirect(url_for('admin.movie_add'))
file_url = secure_filename(form.url.data.filename)
file_logo = secure_filename(form.logo.data.filename)
if not os.path.exists(app.config["UP_DIR"]):
os.makedirs(app.config["UP_DIR"])
os.chmod(app.config["UP_DIR"], "rw")
url = change_filename(file_url)
logo = change_filename(file_logo)
form.url.data.save(app.config["UP_DIR"] + url)
form.logo.data.save(app.config["UP_DIR"] + logo)
movie = Movie(title=data["title"],
url=url,
info=data["info"],
logo=logo,
star=int(data["star"]),
playnum=0,
commentnum=0,
tag_id=int(data["tag_id"]),
area=data["area"],
release_time=data["release_time"],
length=data["length"])
db.session.add(movie)
db.session.commit()
flash("添加电影成功！", "ok")
reason = "添加电影: %s" % movie.title
add_oplog(reason)
return redirect(url_for('admin.movie_add'))
return render_template("admin/movie_add.html", form=form)
def movie_add():
form = MovieForm()
if form.validate_on_submit():
data = form.data
movie = Movie(
title = data["title"],
url = url,
info = data["info"],
logo = logo,
star = data["star"],
playnum = 0,
commentnum = 0,
tag_id = data["tag_id"],
area = data["area"],
lenth = data["lenth"],
release_time = data["release_time"]
)
db.session.add(movie)
db.session.commit()
flash("添加电影成功！","ok")
return redirect(url_for("admin.movie_add"))
return render_template("admin/movie_add.html",form=form)
def setUp(self):
"""Define test variables and initialize app."""
self.app = create_app()
self.client = self.app.test_client
self.database_name = "capstoneDB_test"
self.database_path = os.getenv("TEST_DATABASE_URL")
setup_db(self.app, self.database_path, self.database_name)
self.movie = Movie(title="instersteller", release_date="2014-4-4")
self.actor = Actor(name="tom cruise", age=55, gender="M")
self.casting_producer_jwt = os.getenv("CASTING_PRODUCER_JWT")
self.casting_director_jwt = os.getenv("CASTING_DIRECTOR_JWT")
self.casting_assistant_jwt = os.getenv("CASTING_ASSISTANT_JWT")
# binds the app to the current context
with self.app.app_context():
db = SQLAlchemy()
db.init_app(self.app)
# create all tables
db.create_all()
def movie_add():
form = MovieForm()
# 编写验证逻辑
if form.validate_on_submit():
# 获取前端表单数据
data = form.data
file_url = secure_filename(form.url.data.filename)
# fiel_logo=form.logo.data.filename
# 包裹之后，安全
file_logo = secure_filename(form.logo.data.filename)
if not os.path.exists(app.config["UP_DIR"]):
# 创建文件目录
os.makedirs(app.config["UP_DIR"])
# 增加读写的权限
os.chmod(app.config["UP_DIR"], "rw")
url = change_filename(file_url)
logo = change_filename(file_logo)
# 然后进行保存操作
form.url.data.save(app.config["UP_DIR"] + url)
form.logo.data.save(app.config["UP_DIR"] + logo)
movie = Movie(
title=data['title'],
# 文件上传保存路径
url=url, # 在init文件里面设设置
info=data['info'],
logo=logo,
star=int(data["star"]),
playnum=0,
commentnum=0,
tag_id=int(data["tag_id"]),
area=data["area"],
release_time=data["release_time"],
length=data["length"])
db.session.add(movie)
db.session.commit()
flash("添加电影成功！", "ok")
return redirect(url_for("admin.movie_add"))
return render_template("admin/movie_add.html", form=form)
def process_results(movie_list):
'''
Function that processes the movie result and transform them to a list of Objects
Args:
movie_list: A list of dictionaries that contain movie details
Returns :
movie_results: A list of movie objects
'''
movie_results = []
for movie_item in movie_list:
id = movie_item.get('id')
title = movie_item.get('original_title')
overview = movie_item.get('overview')
poster = movie_item.get('poster_path')
vote_average = movie_item.get('vote_average')
vote_count = movie_item.get('vote_count')
movie_object = Movie(id, title, overview, poster, vote_average,
vote_count)
movie_results.append(movie_object)
return movie_results
def post_movie():
if not session.get("user"):
return redirect(url_for("home.index"))
form = PostMovieForm()
if form.validate_on_submit():
data = form.data
if not data['vote_count']:
data['vote_count'] = 0
if not data['vote_average']:
data['vote_average'] = 0.0
if not data['runtime']:
data['runtime'] = 0.0
movie = Movie(title=data['title'],
language=data['language'],
genre=data['genre'],
overview=data['overview'],
release_date=data['release_date'],
runtime=data['runtime'],
vote_count=data['vote_count'],
director=data['director'],
star=data['star'],
writer=data['writer'],
country=data['country'],
vote_average=data['vote_average'])
posts = json.dumps(movie, default=Movie.movie2json)
headers = {'Content-Type': 'application/json'}
r = requests.post('http://127.0.0.1:5000/movies',
headers=headers,
data=posts)
if r.status_code == 201:
log = Log(request.remote_addr, time(), 'Post Movie')
r = requests.post('http://127.0.0.1:5000/movies/logging',
headers=headers,
data=json.dumps(log, default=Log.log2json))
return redirect(url_for("home.index"))
else:
flash("Something Error!", "err")
return redirect(url_for("home.post_movie"))
return render_template("home/post.html", form=form)
def movie_add():
"""
电影添加页面, 这里的电影播放器能够正常使用
"""
form = MovieForm()
form.tag_id.choices = [(v.id, v.name) for v in Tag.query.all()]
if form.validate_on_submit() is True:
data = form.data
path = create_app().config['UP_DIR']
if os.path.exists(path) is False:
os.makedirs(path) # 当保存路径不存在时进行创建 √
url = change_filename(form.url.data.filename)
logo = change_filename(form.logo.data.filename)
form.url.data.save(path + url)
form.logo.data.save(path + logo)
movie = Movie( # 能够将文件名成功保存到数据库中 √
title=data['title'],
url=url,
info=data['info'],
logo=logo,
star=int(data['star']),
play_num=0,
comment_num=0,
tag_id=int(data['tag_id']),
area=data['area'],
release_time=data['release_time'],
length=data['length'],
)
db.session.add(movie)
db.session.commit()
flash('电影添加成功', 'ok')
return redirect(url_for('admin.movie_add'))
return render_template('admin/movie_add.html', form=form)
def parse(self):
for list in self.lists:
dt = self.get_date_from_tag(list.div.strong)
if dt is None:
continue
movie_list = []
for child in list.ul.find_all('li'):
contents = child.dl.find_all('span', 'link_txt')
movie = Movie()
movie.title = self.get_title_from_tag(child)
movie.genre = self.get_genre_list_from_tag(contents[0])
movie.director = self.get_director_list_from_tag(contents[1])
try:
movie.actor = self.get_actor_list_from_tag(contents[2])
except IndexError:
movie.actor = ""
movie_list.append(movie)
self.result[dt] = movie_list
def post_movie():
data = request.body.readline()
# if not data:
# abort(400, 'No data received')
entity = json.loads(data)
# if not entity.has_key('title'):
# abort(400, 'No title specified')
try:
movie = Movie()
movie.title = entity["title"]
movie.year = entity["year"]
movie.runtime = entity["runtime"]
movie.category = entity["category"]
movie_key = movie.put()
return {"error": False, "data": movie.to_dict()}
except Exception, e:
return {"error": True, "message": e}
if name:
mapped = data_name_mapping.get(column.get('name'))
column_pos[mapped] = pos
pos += 1
for movie_data in data.get('data'):
movie_api_id = movie_data[column_pos.get('api_id')]
title = movie_data[column_pos.get('title')]
year = movie_data[column_pos.get('year')]
director = movie_data[column_pos.get('director')]
movie = Movie.query.filter(Movie.title == title,
Movie.year == year,
Movie.director == director).first()
if not movie:
movie = Movie()
movie.api_id = movie_data[column_pos.get('api_id')]
sys.stdout.write('\rNEW Movie %s' % movie.api_id)
movie.title = movie_data[column_pos.get('title')]
movie.year = movie_data[column_pos.get('year')]
movie.director = movie_data[column_pos.get('director')]
# Set actors
actors = [
movie_data[column_pos.get('actor_1')],
movie_data[column_pos.get('actor_2')],
movie_data[column_pos.get('actor_3')]
]
for actor_name in [a for a in actors if a]:
actor = Actor.query.filter(Actor.name == actor_name).first()
if not actor:
actor = Actor(actor_name)
def get_movie_item(id):
movie = Movie.get_by_id(int(id))
data = movie.to_dict()
data["id"] = movie.key.id()
return {"error": False, "data": data}
def movie(movie):
movie = Movie.get_movie(movie)
return jsonify(movie)
def movies():
limit = request.args.get("limit")
movies_ = Movie.get_movies(limit)
movies = json.dumps(movies_)
return make_response(movies)
