def book_export():
book_type = request.args.get('book_type')
project_id = request.args.get('project_id')
query = book_service.get_book_query(book_type, project_id)
res = Search().init_query(query).load(Book).paginate()
res['items'] = Project.bindTitles(res.get('items', []))
return api_success(res)
def get_video(video_id):
video = Video.get_one(video_id)
project = video_service.get_video_project(video_id)
res = video.to_dict()
res['file_size'] = round(res['file_size'] / 1024 / 1024, 2)
res['projects'] = project
return api_success(res)
def create_project_books(project_id):
# 专题创建图书
project = Project.query.get_or_404(project_id)
books = request.json.get('books', [])
ProjectBook.generate(project.id, books)
res = project.get_with_books()
return api_success(res)
def add_picture():
data = request.json
picture = Picture.create(data)
res = picture.to_dict()
project_ids = data.get('project_ids', [])
picture_service.generate_project(project_ids, res['id'])
return api_success(res)
def picture_export():
type_ = request.args.get('type')
project_id = request.args.get('project_id')
query = picture_service.get_picture_query(project_id, type_)
res = Search().init_query(query).load(Picture).paginate()
res['items'] = picture_service.bindTitles(res.get('items', []))
return api_success(res)
def video_export():
project_id = request.args.get('project_id')
query = video_service.get_video_query(project_id)
res = Search().init_query(query).load(Video).paginate()
res['items'] = video_service.bindTitles(res.get('items', []))
for item in res['items']:
item['file_size'] = round(item['file_size'] / 1024 / 1024, 2)
return api_success(res)
def upload_videos():
files = request.files.getlist('file')
if not files:
raise ApiError('请选择要上传的文件')
data = upload_to_videos(files)
if not data:
raise ApiError('上传失败')
return api_success(data)
def get_project_picture(project_id):
# 获取专题轮播图
project = Project.query.get_or_404(project_id)
ids = project.picture_sort
project_picture = ProjectPicture.query.\
filter(ProjectPicture.picture_id.in_(ids)).\
filter_by(project_id=project_id).\
all()
picture_ids = [p.picture_id for p in project_picture]
sort_ids = [i for i in ids if i in picture_ids]
project.picture_sort = sort_ids
project.save()
pictures = Picture.query.filter(Picture.id.in_(picture_ids)).all()
if len(picture_ids) != 0:
res = bind_pictures(pictures, sort_ids)
return api_success(res)
return api_success([])
def get_project():
# 获取专题列表
projects = Project.query.\
with_entities(Project.title,
Project.id).\
all()
res = [p._asdict() for p in projects]
return api_success(res)
def admin_login():
phone = request.json.get('phone')
password = request.json.get('password')
admin = Admin.query.filter_by(phone=phone).first()
if not admin:
raise ApiError('用户不存在')
if not admin.verify_password(password):
raise ApiError('密码错误')
return api_success(admin.to_dict())
def picture_set_order(project_id):
# 专题排序轮播图
project = Project.query.get_or_404(project_id)
sorted_ids = request.json.get('sorted_ids', [])
if len(sorted_ids) == 0:
raise ApiError('轮播图的id列表不能为空')
project.picture_sort = sorted_ids
res = project.picture_sort
project.save()
return api_success(res)
def delete_project_picture(project_id, picture_id):
# 专题删除轮播图
project = Project.query.get_or_404(project_id)
picture = Picture.query.get_or_404(picture_id)
ProjectPicture.remove_picture(project_id, picture_id)
new_picture_sort = copy.deepcopy(project.picture_sort)
new_picture_sort.remove(picture.id)
project.picture_sort = new_picture_sort
project.save()
return api_success(msg='专题图书删除成功')
def update_picture(picture_id):
picture = Picture.query.get(picture_id)
if not picture:
raise ApiError('图片不存在')
data = request.json
picture = picture.update(data)
res = picture.to_dict()
project_ids = data.get('project_ids', [])
picture_service.generate_project(project_ids, picture_id)
return api_success(res)
def update_book(id_):
book = Book.query.get(id_)
if not book:
raise ApiError('书本不存在')
data = request.json
book = book.update(data)
book = book.to_dict()
project_ids = data.get('project_ids', [])
Project.generate_project(id_, project_ids)
return api_success(book)
def admin_update(admin_id):
name = request.json.get('name')
phone = request.json.get('phone')
data = {
'name': name,
'phone': phone
}
admin = Admin.query.get_or_404(admin_id)
res = admin.update(data)
return api_success(res.to_dict())
def add_video():
data = request.json
data['file_type'] = os.path.splitext(data['file_path'])[1].strip('.')
if data['file_type'] not in video_allow_extensions:
raise ApiError('视频格式不正确')
data['file_size'] = video_service.get_size(data['file_path'])
video = Video.create(data)
res = video.to_dict()
project_ids = data.get('project_ids', [])
video_service.generate_project(res['id'], project_ids)
return api_success(res)
def upload_attachment():
file_ = request.files.get('file')
if not file_:
raise ApiError('请选择要上传的文件')
data = upload_to_images(file_)
if data.get('status') is True:
res = {
'url': data.get('url', ''),
}
return api_success(res)
raise ApiError('上传失败')
def update_video(video_id):
video = Video.query.get(video_id)
if not video:
raise ApiError('视频不存在')
data = request.json
data['file_size'] = video.file_size
video = video.update(data)
res = video.to_dict()
project_ids = data.get('project_ids',[])
video_service.generate_project(video_id, project_ids)
return api_success(res)
def get_device_project():
# 获取当前设备所选专题
project_id = g.current_device.project_id
project = Project.query.\
with_entities(Project.title, Project.theme_id,
Project.id).\
filter_by(id=project_id).\
first_or_404()
res = project._asdict()
res['title_first'] = res['title'][:2]
res['title_second'] = res['title'][2:]
return api_success(res)
def device_save_project():
# 设备新增专题
device_code = request.json.get('device_code')
project_id = request.json.get('project_id')
Project.query.get_or_404(project_id)
device = Device.query.filter_by(device_code=device_code).first()
if not device:
device = Device(device_code=device_code, project_id=project_id)
if device.project_id == 0:
device.project_id = project_id
device.save()
return api_success(device.to_dict())
def change_password(admin_id):
old_password = request.json.get('old_password')
new_password = request.json.get('new_password')
check_new_password = request.json.get('check_new_password')
admin = Admin.query.get_or_404(admin_id)
if not admin.verify_password(old_password):
raise ApiError('原密码有误')
if new_password != check_new_password:
raise ApiError('两次密码不一致')
admin.password = Admin.generate_password(new_password)
admin.save()
return api_success(msg='密码修改成功')
def read_book(book_id):
query = Book.query.with_entities(Book.id).\
filter_by(id=book_id)
book = query.first()
if not book:
raise ApiError('书本不存在')
query.update({'read_count': Book.read_count + 1})
db.session.commit()
books = Book.query.with_entities(Book.id, ProjectBook.project_id).\
join(ProjectBook, Book.id==ProjectBook.book_id).\
filter(Book.id==book_id).all()
StatisticLog.add_read_book_record(books)
return api_success(books)
def create_project():
# 创建专题
title = request.json.get('title')
project = Project.query.filter_by(title=title).first()
if project:
raise ApiError('专题名称不可重复')
data = {
'title': title,
'summary': request.json.get('summary', ''),
'creater_id': g.admin.id
}
res = Project.create(data)
return api_success(res.to_dict())
def play_video(video_id):
query = Video.query.with_entities(Video.id).\
filter_by(id=video_id)
video = query.first()
if not video:
raise ApiError('视频不存在')
query.update({'play_count': Video.play_count + 1})
db.session.commit()
query = Video.query.with_entities(Video.id, ProjectVideo.project_id).\
join(ProjectVideo, Video.id==ProjectVideo.video_id).\
filter(Video.id==video_id)
videos = query.all()
StatisticLog.add_play_count_record(videos)
return api_success(videos)
def update_project(project_id):
# 编辑专题
title = request.json.get('title')
list_project_id = [project_id]
project_title = Project.query.filter(~Project.id.in_(list_project_id)).\
filter_by(title=title).\
first()
if project_title:
raise ApiError('专题名称不可重复')
project = Project.query.get_or_404(project_id)
data = {
'title': title,
'summary': request.json.get('summary', '')
}
res = project.update(data)
return api_success(res.to_dict())
def upload_video():
file_ = request.files.get('file')
if not file_:
raise ApiError('请选择要上传的文件')
data = upload_to_video(file_)
url = data.get('url', '')
file_size = round(video_service.get_size(url) / 1024 / 1024, 2)
if data.get('status') is True:
res = {
'url': url,
'thumbnail': data.get('thumbnail', ''),
'file_size': file_size,
'file_name': file_.filename
}
return api_success(res)
raise ApiError('上传失败')
def upload_ebook():
file_ = request.files.get('file')
if not file_:
raise ApiError('请选择要上传的文件')
data = upload_book(file_)
if data.get('status') is True:
if not os.path.splitext(data['url'])[1] == '.pdf':
metadata = parse_epub_info(file_)
else:
metadata = ''
res = {
'file': data.get('url', ''),
'metadata': metadata,
'pdf_image': data.get('pdf_image') if data.get('pdf_image') else ''
}
return api_success(res)
raise ApiError('上传失败')
def add_book():
data = request.json
data['file_type'] = os.path.splitext(data['file_path'])[1].strip('.')
data['file_size'] = book_service.get_size(data['file_path'])
if data['file_type'] == 'epub':
file_path = current_app.config['APP_PATH'] + data['file_path']
opf_path = book_service.generate_opf_from_epub(file_path,
data['file_path'])
data['opf_path'] = os.path.join((data['file_path'] + "_files/"),
opf_path)
if not data.get('image') and data['file_type'] == 'epub':
cover_path = book_service.cover_path_from_epub(data['file_path'])
data['image'] = cover_path
book = Book.create(data)
project_ids = data.get('project_ids', [])
res = book.to_dict()
Project.generate_project(book.id, project_ids)
return api_success(res)
def get_project():
# 获取专题列表
projects = Project.query.with_entities(Project.id, Project.title, Project.summary).all()
project_books = Book.query.\
join(ProjectBook, Book.id==ProjectBook.book_id). \
with_entities(ProjectBook.project_id, func.count(ProjectBook.book_id).label('book_count')).\
filter(Book.book_type=='book').\
group_by(ProjectBook.project_id).all()
project_pictures = Picture.query.\
join(ProjectPicture, Picture.id==ProjectPicture.picture_id). \
with_entities(ProjectPicture.project_id, func.count(ProjectPicture.picture_id).label('banner_count')).\
filter(Picture.type=='banner').\
group_by(ProjectPicture.project_id).all()
pb_count_dict = {pb.project_id: pb.book_count for pb in project_books}
pp_count_dict = {pp.project_id: pp.banner_count for pp in project_pictures}
projects = [p._asdict() for p in projects]
for project in projects:
project['book_count'] = pb_count_dict.get(project['id'], 0)
project['picture_count'] = pp_count_dict.get(project['id'], 0)
return api_success(projects)
def create_project_picture(project_id):
# 专题添加轮播图
project = Project.query.get_or_404(project_id)
picture_ids = request.json.get('picture_ids', [])
ProjectPicture.generate_project_picture(project_id, picture_ids)
pictures = Picture.query.\
filter(Picture.id.in_(picture_ids)).\
all()
ids = {p.id: p.id for p in pictures}
image_ids = []
for i in picture_ids:
if ids.get(i):
image_ids.append(ids.get(i))
new_picture_sort = copy.deepcopy(project.picture_sort)
for _id in image_ids:
if _id in new_picture_sort:
continue
new_picture_sort.insert(0, _id)
project.picture_sort = new_picture_sort
res = project.get_with_pictures()
project.save()
return api_success(res)
