def delete_banner():
result = {'response': 'ok', 'info': ''}
ids = request.form.get('ids').split(',')
try:
with get_session() as db_session:
if ids[0]:
db_session.query(Banner).filter(
Banner.id.in_(ids)).delete(synchronize_session=False)
db_session.commit()
else:
result.update({'response': 'fail', 'info': u'当前未选择任何图片'})
return jsonify(result)
except Exception as e:
app.my_logger.error(traceback.format_exc(e))
abort(400)
def get_series_list_page():
result = {'response': 'ok', 'series_category': '', 'series_list': []}
# 当前connect_id为专题分类id
connect_id = request.args.get('id')
page = request.args.get('page', 1)
limit = 12
try:
with get_session() as db_session:
image_series_category = db_session.query(ImageSeriesCategory).get(
connect_id)
image_series_category_dict = image_series_category.to_dict()
result['series_category'] = image_series_category_dict
query = db_session.query(ImageSeriesCategoryRel).join(
ImageSeriesCategory, ImageSeriesCategory.id ==
ImageSeriesCategoryRel.category_id).filter(
ImageSeriesCategory.id == connect_id).all()
image_series_ids = [
image_series_category_rel.series_id
for image_series_category_rel in query
]
query = db_session.query(ImageSeries).filter(
ImageSeries.id.in_(image_series_ids)).order_by(
-ImageSeries.created_date)
paginator = SQLAlchemyPaginator(query, limit)
page = paginator.get_validate_page(page)
_image_series_list = list()
for image_series in paginator.page(page):
image_series_dict = image_series.to_dict()
image_series_dict['is_collected'] = False
width, height = image_series.get_cover_img_info()
image_series_dict['width'] = width
image_series_dict['height'] = height
_image_series_list.append(image_series_dict)
result['series_list'] = _image_series_list
result.update({
'meta': {
'cur_page': page,
'all_page': paginator.max_page,
'count': paginator.count
}
})
return jsonify(result)
except Exception as e:
print e
def discount_update():
result = {
'response': 'ok',
'info': ''
}
_id = request.form.get('id')
name = request.form.get('name')
status = request.form.get('status')
times = request.form.get('times')
price = request.form.get('price')
effect_days = request.form.get('effect_days')
image_id = request.form.get('img_id')
level = request.form.get('level')
description = request.form.get('description')
try:
with get_session() as db_session:
if not _id:
discount = Discount()
discount.name = name
discount.status = status
discount.times = times
discount.price = price
discount.effect_days = effect_days
discount.image_id = image_id
discount.description = description
discount.level = level
db_session.add(discount)
else:
discount = db_session.query(Discount).get(_id)
if discount:
discount.name = name
discount.status = status
discount.times = times
discount.price = price
discount.effect_days = effect_days
discount.image_id = image_id
discount.description = description
discount.level = level
else:
result.update({
'response': 'fail',
'info': u'当前对象不存在'
})
db_session.commit()
return jsonify(result)
except Exception as e:
print traceback.format_exc(e)
def get_png_image_from_keyword(keyword):
"""
:param keyword: 要搜索的关键词
:return: json格式的数据
"""
url = result_url
result = {'response': 'ok', 'code': 0, 'info': ''}
data = {'word': keyword, 'noresult': ''}
response = post_requests(url, data)
if response:
r = ujson.loads(response.content)
status = r.get(u'status')
# 获取成功
if status == 1:
data_list = r.get(u'data', [])
if data_list:
with get_session() as db_session:
for data in data_list:
print data
pic_width = data.get(u'picwidth', u'')
pic_height = data.get(u'picheight', u'')
pic_title = data.get(u'title', u'')
pic_url = data.get(u'picurl', u'')
pic_id = data.get(u'id', u'')
pic_image = db_session.query(PIC58Image).filter(
PIC58Image.pic_id == pic_id).first()
if not pic_image:
pic_image = PIC58Image()
pic_image.key_word = ','.join(keyword)
pic_image.pic_height = pic_height
pic_image.pic_width = pic_width
pic_image.pic_name = pic_title
pic_image.pic_url = pic_url
pic_image.pic_id = pic_id
db_session.add(pic_image)
db_session.commit()
else:
result.update({
'response': 'fail',
'code': 2,
'info': u'获取图片信息失败'
})
return ujson.dumps(result)
else:
result.update({'response': 'fail', 'code': 1, 'info': u'获取信息失败'})
return ujson.dumps(result)
def get_hot_search_detail():
result = {'response': 'ok', 'info': '', 'hot_search': '', 'all_series': []}
_id = request.args.get('id')
try:
with get_session() as db_session:
hot_search = db_session.query(WebsiteHotSearch).get(_id)
all_series = db_session.query(ImageSeries).all()
all_series_list = [series.to_dict() for series in all_series]
result.update({'all_series': all_series_list})
if hot_search:
hot_search_dict = hot_search.to_dict()
result['hot_search'] = hot_search_dict
else:
result.update({'response': 'fail', 'info': u'当前热搜关键词不存在'})
return jsonify(result)
except Exception as e:
print e
def get_menu_func_detail():
result = {'response': 'ok', 'menu_func': ''}
try:
menu_func_id = request.args.get('id')
menu_select_info = list()
menu_select_info = Menu.get_menu_select_info(menu_select_info)
result['menu_select_info'] = menu_select_info
result['func_select_info'] = Func.get_func_select_info()
with get_session() as db_session:
menu_func = db_session.query(MenuFunc).get(menu_func_id)
if menu_func:
menu_func_dict = menu_func.to_dict()
result['menu_func'] = menu_func_dict
return jsonify(result)
except Exception as e:
app.my_logger.error(traceback.format_exc(e))
abort(400)
def get_role_permission_detail():
result = {
'response': 'ok',
'role': '',
'all_menu_func_list': list(),
'all_role_permission_list': list()
}
try:
role_id = request.args.get('id')
with get_session() as db_session:
# 角色信息
role = db_session.query(Role).get(role_id)
role_dict = role.to_dict()
result['role'] = role_dict
# 菜单信息
all_menu = db_session.query(Menu).filter(Menu.parent_id == 0).all()
all_menu_list = list()
for menu in all_menu:
menu_dict = menu.to_dict()
sub_menus = menu_dict.get('sub_menus')
for sub_menu in sub_menus:
all_sub_menu_func = db_session.query(MenuFunc).filter(
MenuFunc.menu_id == sub_menu.get('id')).all()
sub_menu_func_list = list()
for sub_menu_func in all_sub_menu_func:
sub_menu_func_dict = sub_menu_func.to_dict()
sub_menu_func_list.append(sub_menu_func_dict)
sub_menu['all_sub_menu_func'] = sub_menu_func_list
all_menu_list.append(menu_dict)
result['all_menu_func_list'] = all_menu_list
# 角色权限信息
role_all_permission = db_session.query(RolePermissionRel).filter(
RolePermissionRel.role_id == role_id).all()
all_role_permission_list = list()
for role_permission in role_all_permission:
all_role_permission_list.append(
str(role_permission.menu_func_id))
result['all_role_permission_list'] = all_role_permission_list
return jsonify(result)
except Exception as e:
app.my_logger.error(traceback.format_exc(e))
abort(400)
def change_menu_sort():
result = {'response': 'ok', 'info': ''}
try:
menu_id = request.form.get('menu_id')
change_method = request.form.get('change_method')
with get_session() as db_session:
if None in [menu_id, change_method]:
result.update({'response': 'fail', 'info': u'请检查参数是否填写完整'})
else:
menu = db_session.query(Menu).get(menu_id)
if menu:
# 只能在同一层级中移动位置
if change_method == 'up':
_menu = db_session.query(Menu).filter(
Menu.parent_id == menu.parent_id,
Menu.sort < menu.sort).first()
if _menu:
_sort = menu.sort
menu.sort = _menu.sort
_menu.sort = _sort
else:
result.update({
'response': 'fail',
'info': u'当前菜单已位于最顶端'
})
if change_method == 'down':
_menu = db_session.query(Menu).filter(
Menu.parent_id == menu.parent_id,
Menu.sort > menu.sort).first()
if _menu:
_sort = menu.sort
menu.sort = _menu.sort
_menu.sort = _sort
else:
result.update({
'response': 'fail',
'info': u'当前菜单已位于最底端'
})
db_session.commit()
else:
result.update({'response': 'fail', 'info': u'获取当前对象失败'})
return jsonify(result)
except Exception as e:
app.my_logger.error(traceback.format_exc(e))
abort(400)
def update_image_tag_detail():
result = {
'response': 'ok',
'info': ''
}
image_tag_id = request.form.get('id')
image_tag_name = request.form.get('name')
try:
if None in [image_tag_name]:
result.update({
'response': 'fail',
'info': u'请检查参数是否填写完整'
})
else:
with get_session() as db_session:
if not image_tag_id:
has_tag = db_session.query(ImageTags).filter(
ImageTags.name == image_tag_name
).first()
if has_tag:
result['response'] = 'fail'
result['info'] = u'当前标签已存在'
else:
image_tag = ImageTags()
image_tag.name = image_tag_name
db_session.add(image_tag)
else:
image_tag = db_session.query(ImageTags).get(image_tag_id)
if image_tag:
has_tag = db_session.query(ImageTags).filter(
ImageTags.name == image_tag_name
).first()
if has_tag:
result['response'] = 'fail'
result['info'] = u'当前标签已存在'
else:
image_tag.name = image_tag_name
else:
result['response'] = 'fail'
result['info'] = u'当前对象不存在'
db_session.commit()
return jsonify(result)
except Exception as e:
app.my_logger.error(traceback.format_exc(e))
abort(400)
def get_discount_list():
result = {
'response': 'ok',
'discount_list': []
}
try:
discount_list = list()
with get_session() as db_session:
all_discount = db_session.query(Discount).order_by(-Discount.created_date).all()
for discount in all_discount:
discount_dict = discount.to_dict()
discount_list.append(discount_dict)
result.update({
'discount_list': discount_list
})
return jsonify(result)
except Exception as e:
print traceback.format_exc(e)
def user_menu(self):
key = u'user_menu_%s' % self.id
menu_list = common_redis.get(key)
if not menu_list:
with get_session() as db_session:
user_roles = db_session.query(UserRole).filter(
UserRole.user_id == self.id).all()
user_role_ids = [user_role.id for user_role in user_roles]
menu_list = list()
all_menu = db_session.query(RolePermissionRel).filter(
RolePermissionRel.role_id.in_(user_role_ids),
RolePermissionRel.permission_type ==
RolePermissionRel.TYPE_MENU).all()
if all_menu:
menu_list = [menu.id for menu in all_menu]
return menu_list
def get_column_list():
result = {
'response': 'ok',
'column_list': [],
}
try:
with get_session() as db_session:
query = db_session.query(WebsiteColumn).order_by(WebsiteColumn.ranking).all()
_column_list = list()
for column in query:
column_dict = column.to_dict()
_column_list.append(column_dict)
result.update({
'column_list': _column_list
})
return jsonify(result)
except Exception as e:
print e
def image_series_list():
result = {
'response': 'ok',
'image_series_list': [],
'info': ''
}
try:
with get_session() as db_session:
all_image_series = db_session.query(ImageSeries).all()
_image_series_list = list()
for image_series in all_image_series:
image_series_dict = image_series.to_dict()
_image_series_list.append(image_series_dict)
result['image_series_list'] = _image_series_list
return jsonify(result)
except Exception as e:
print e
abort(400)
def get_image_object(key_word=None):
with get_session() as db_session:
query = db_session.query(PIC58Image).filter(
PIC58Image.status == PIC58Image.STATUS_DEFAULT)
if key_word:
query = query.filter(PIC58Image.key_word == key_word)
query = query.order_by(-PIC58Image.created_date)
all_image_count = query.count()
all_image = query.all()
count = 1
if all_image:
for image in all_image:
try:
img_key_word = image.key_word
base_url = os.path.dirname(__file__)
file_url = os.path.join(base_url, 'object')
file_path = os.path.join(file_url,
img_key_word).replace('\\', '/')
if not os.path.exists(file_path):
os.makedirs(file_path)
img_url = image.pic_url.split('!')[0]
img_type = img_url.split('.')[-1]
img_title = '.'.join([image.pic_name, img_type])
img_title = img_title.replace(r'<i>',
'').replace(r'</i>', '')
print u'----------------- 正在获取%s 剩余%s----------------' % (
img_title, all_image_count - count)
img_name = os.path.join(file_path,
img_title).replace('\\', '/')
if os.path.exists(img_name):
pic_name = image.pic_name + str(int(time.time()))
img_title = '.'.join([pic_name, img_type])
img_name = os.path.join(file_path,
img_title).replace('\\', '/')
time.sleep(10)
img_response = requests.get(img_url, timeout=50)
with open(img_name, 'wb') as f:
f.write(img_response.content)
image.status = PIC58Image.STATUS_USED
count += 1
db_session.commit()
except Exception as e:
print traceback.format_exc(e)
continue
def update_user():
result = {'response': 'ok', 'info': u'修改信息成功'}
c_id = request.form.get('id', None)
name = request.form.get('name', None)
qq = request.form.get('qq', None)
sex = request.form.get('sex', Customer.UNKNOWN)
try:
with get_session() as db_session:
customer = db_session.query(Customer).get(c_id)
if customer:
customer.name = name
customer.sex = sex
customer.qq = qq
db_session.commit()
else:
result.update({'response': 'fail', 'info': u'当前用户不存在'})
return jsonify(result)
except Exception as e:
print e
def banner_list():
result = {
'response': 'ok',
'banner_list': [],
}
try:
_banner_list = list()
with get_session() as db_session:
all_banner = db_session.query(Banner).all()
for banner in all_banner:
banner_dict = banner.to_dict()
img_url = banner.get_banner_img(db_session)
banner_dict['img_url'] = img_url
_banner_list.append(banner_dict)
result['banner_list'] = _banner_list
return jsonify(result)
except Exception as e:
app.my_logger.error(traceback.format_exc(e))
abort(400)
def get_image_detail():
result = {
'response': 'ok',
'image': '',
'is_collected': False,
'tag_list': [],
'info': ''
}
image_id = request.args.get('id')
try:
with get_session() as db_session:
image = db_session.query(Image).get(image_id)
if image:
# 图片浏览量+1
image.view_count += 1
image_dict = image.to_dict()
result['image'] = image_dict
db_session.commit()
# 如果当前用户收藏了该图片则显示
if current_user.is_authenticated():
image_collect = db_session.query(CustomerCollect).filter(
CustomerCollect.collect_id == image_id,
CustomerCollect.customer_id == current_user.id,
CustomerCollect.type ==
CustomerCollect.TYPE_IMAGE).first()
if image_collect:
result['is_collected'] = True
# 获取图片的标签
tag_list_query = db_session.query(ImageTags).join(
ImageTagsRel, ImageTags.id == ImageTagsRel.tag_id).filter(
ImageTagsRel.image_id == image_id).all()
tag_list = list()
for tag in tag_list_query:
tag_dict = tag.to_dict()
tag_list.append(tag_dict)
result['tag_list'] = tag_list
else:
result.update({'response': 'fail', 'info': u'抱歉~图片好像走丢了...'})
return jsonify(result)
except Exception as e:
print e
def request(self, req):
"""
Entry point for the API
req contains a json structure, if the
"""
session = get_session(req)
action = {
'request_token': [request_token, False]
}.get(req.get('action'), [None, True])
action_func = action[0]
action_auth = action[1]
if action_auth and session is None:
return self.reply()
if action_func is not None:
# possibly we can get a different session back
session = action_func(session, req)
return self.reply(session)
def get_menu_func_list():
result = {'response': 'ok', 'menu_func_list': []}
try:
with get_session() as db_session:
query = db_session.query(MenuFunc, Menu, Func).join(
Menu, Menu.id == MenuFunc.menu_id).join(
Func,
Func.id == MenuFunc.func_id).order_by(Menu.code).all()
for menu_func, menu, func in query:
menu_func_dict = menu_func.to_dict()
menu_func_dict.update({
'menu_name': menu.name,
'func_name': func.name
})
result['menu_func_list'].append(menu_func_dict)
return jsonify(result)
except Exception as e:
app.my_logger.error(traceback.format_exc(e))
abort(400)
def update_menu_detail():
result = {'response': 'ok', 'info': ''}
try:
menu_id = request.form.get('id')
menu_name = request.form.get('name')
menu_code = request.form.get('code')
parent_id = request.form.get('parent_id')
icon_info = request.form.get('icon_info')
module = request.form.get('module')
url = request.form.get('url')
if None in [menu_name, menu_code, parent_id]:
result.update({'response': 'fail', 'info': u'请检查参数是否填写完整'})
else:
with get_session() as db_session:
if not menu_id:
menu = Menu()
menu.name = menu_name
menu.code = menu_code
menu.parent_id = parent_id
menu.icon_info = icon_info
# 设置同层级菜单的排序位置
menu.sort = Menu.set_count(parent_id)
menu.url = url
menu.module = module
db_session.add(menu)
else:
menu = db_session.query(Menu).get(menu_id)
if menu:
menu.name = menu_name
menu.code = menu_code
menu.parent_id = parent_id
menu.icon_info = icon_info
menu.url = url
menu.module = module
else:
result['response'] = 'fail'
result['info'] = u'当前对象不存在'
db_session.commit()
return jsonify(result)
except Exception as e:
app.my_logger.error(traceback.format_exc(e))
abort(400)
def user_permission(self):
key = u'user_permission_%s' % self.id
permission_list = common_redis.get(key)
if not permission_list:
with get_session() as db_session:
user_roles = db_session.query(UserRole).filter(
UserRole.user_id == self.id).all()
user_role_ids = [user_role.id for user_role in user_roles]
permission_list = list()
all_permission = db_session.query(RolePermissionRel).filter(
RolePermissionRel.role_id.in_(user_role_ids),
RolePermissionRel.permission_type ==
RolePermissionRel.TYPE_MENU_FUNC).all()
if all_permission:
permission_list = [
permission.id for permission in all_permission
]
return permission_list
def get_article_list():
result = {
'response': 'ok',
'article_list': []
}
try:
with get_session() as db_session:
query = db_session.query(Article).all()
for article in query:
author = db_session.query(User).get(article.author)
if author:
author_name = author.name
else:
author_name = u'佚名'
article_dict = article.to_dict()
article_dict['author_name'] = author_name
result['article_list'].append(article_dict)
return jsonify(result)
except Exception as e:
print traceback.format_exc(e)
def get_menu_select_info(cls,
menu_select_info=list(),
parent_id=0,
level=0):
with get_session() as db_session:
menus = db_session.query(Menu).filter(
Menu.parent_id == parent_id).order_by(Menu.sort).all()
for menu in menus:
if menu:
menu_dict = menu.to_dict()
menu_dict.update({
'menu_name':
''.join(['| ', '---- ' * level, menu.name]),
})
menu_select_info.append(menu_dict)
_level = level + 1
cls.get_menu_select_info(menu_select_info, menu.id, _level)
else:
continue
return menu_select_info
def get_hot_search():
result = {
'response': 'ok',
'hot_search_list': [],
}
try:
with get_session() as db_session:
query = db_session.query(WebsiteHotSearch, ImageSeries).join(
ImageSeries,
ImageSeries.id == WebsiteHotSearch.connect_id).order_by(
WebsiteHotSearch.ranking).all()
_hot_search_list = list()
for hot_search, image_series in query:
hot_search_dict = hot_search.to_dict()
hot_search_dict['connect_name'] = image_series.name
_hot_search_list.append(hot_search_dict)
result.update({'hot_search_list': _hot_search_list})
return jsonify(result)
except Exception as e:
print e
def image_tag_association_list():
result = {
'response': 'ok',
'association_tag_str': '',
'tag_id': ''
}
try:
tag_id = request.args.get('tag_id', None)
result['tag_id'] = tag_id
with get_session() as db_session:
association_tag_query = db_session.query(ImageAssociationTag).filter(
ImageAssociationTag.tag_id == tag_id
).all()
if association_tag_query:
association_tag_str = u'，'.join([association_tag.name for association_tag in association_tag_query])
result['association_tag_str'] = association_tag_str
return jsonify(result)
except Exception as e:
print e
abort(400)
def dashboard_info():
result = {'response': 'ok', 'dashboard_info': {}}
try:
yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
yesterday_start = datetime.datetime.strftime(yesterday,
'%Y-%m-%d 00:00:00')
yesterday_end = datetime.datetime.strftime(yesterday,
'%Y-%m-%d 23:59:59')
with get_session() as db_session:
# 会员数量
all_customer = db_session.query(Customer)
all_customer_count = all_customer.count()
result['dashboard_info']['all_customer_count'] = all_customer_count
# 图片数量
all_pic_obj = db_session.query(Image)
all_pic_count = all_pic_obj.count()
result['dashboard_info']['all_pic_count'] = all_pic_count
# 昨日上传图片
upload_pic_obj = all_pic_obj.filter(
Image.created_date >= yesterday_start,
Image.created_date <= yesterday_end)
upload_pic_count = upload_pic_obj.count()
result['dashboard_info']['upload_pic_count'] = upload_pic_count
# 昨日下载图片数量
download_pic_obj = db_session.query(ImageDownloadHistory).filter(
ImageDownloadHistory.created_date >= yesterday_start,
ImageDownloadHistory.created_date <= yesterday_end)
download_pic_count = download_pic_obj.count()
result['dashboard_info']['download_pic_count'] = download_pic_count
# 专题数量
all_series_obj = db_session.query(ImageSeries)
all_series_count = all_series_obj.count()
result['dashboard_info']['all_series_count'] = all_series_count
return jsonify(result)
except Exception as e:
app.my_logger.error(traceback.format_exc(e))
abort(400)
def update_image_series_detail():
result = {
'response': 'ok',
'info': ''
}
image_series_id = request.form.get('id')
image_series_name = request.form.get('name')
image_series_desc = request.form.get('desc')
image_series_short_desc = request.form.get('short_desc')
image_series_type = request.form.get('type')
try:
if None in [image_series_name]:
result.update({
'response': 'fail',
'info': u'请检查参数是否填写完整'
})
else:
with get_session() as db_session:
if not image_series_id:
image_series = ImageSeries()
image_series.name = image_series_name
image_series.desc = image_series_desc
image_series.short_desc = image_series_short_desc
image_series.author = current_user.name
image_series.type = image_series_type
db_session.add(image_series)
else:
image_series = db_session.query(ImageSeries).get(image_series_id)
if image_series:
image_series.name = image_series_name
image_series.desc = image_series_desc
image_series.short_desc = image_series_short_desc
image_series.type = image_series_type
else:
result['response'] = 'fail'
result['info'] = u'当前对象不存在'
db_session.commit()
return jsonify(result)
except Exception as e:
app.my_logger.error(traceback.format_exc(e))
abort(400)
def get_website_conf():
result = {'response': 'ok', 'website_conf': ''}
try:
with get_session() as db_session:
website_conf = db_session.query(WebsiteConf).first()
if website_conf:
website_conf_dict = website_conf.to_dict()
result.update({'website_conf': website_conf_dict})
else:
website_conf = WebsiteConf()
website_conf.website_url = ''
website_conf.resource_url = ''
website_conf.free_download_count = 0
website_conf.free_download_time = 0
db_session.add(website_conf)
db_session.commit()
website_conf_dict = website_conf.to_dict()
result.update({'website_conf': website_conf_dict})
return jsonify(result)
except Exception as e:
print traceback.format_exc(e)
def set_delete_column():
result = {
'response': 'ok',
'info': ''
}
ids = request.form.get('ids').split(',')
try:
if ids[0]:
with get_session() as db_session:
db_session.query(WebsiteColumnSeriesRel).filter(
WebsiteColumnSeriesRel.id.in_(ids)
).delete(synchronize_session=False)
db_session.commit()
else:
result.update({
'response': 'fail',
'info': u'当前未选择任何数据'
})
return jsonify(result)
except Exception as e:
print e
def get_column_detail():
result = {
'response': 'ok',
'info': '',
'column': ''
}
_id = request.args.get('id')
try:
with get_session() as db_session:
column = db_session.query(WebsiteColumn).get(_id)
if column:
column_dict = column.to_dict()
result['column'] = column_dict
else:
result.update({
'response': 'fail',
'info': u'当前栏目不存在'
})
return jsonify(result)
except Exception as e:
print e
