def tag_list():
meta = metaInit.copy()
query = {}
page = int(request.args.get('page', 1))
per_page = 20
status = int(request.args.get('status', 0))
deleted = int(request.args.get('deleted', 0))
page_url = url_for('admin.tag_list', page="#p#", status=status)
if status == -1:
meta['css_disable'] = 'active'
query['status'] = 0
elif status == 1:
query['status'] = 1
meta['css_verify'] = 'active'
elif status == 5:
query['status'] = 5
meta['css_success'] = 'active'
else:
meta['css_all'] = 'active'
query['deleted'] = deleted
current_app.logger.debug(type(g.user))
data = Tag.objects(**query).order_by('-created_at').paginate(
page=page, per_page=per_page)
total_count = Tag.objects(**query).count()
meta['data'] = data.items
pager = Pager(page, per_page, total_count, page_url)
meta['pager'] = pager.render_view()
return render_template('admin/tag/list.html', meta=meta)
def theme_delete(item_id):
"""Remove an item"""
if request.method == "POST":
item = db.session.query(Theme).filter_by(id=item_id).one()
if item is not None:
item_id = item.id
item_theme_author = item.theme_author_id
item_license_type = item.license_type_id
# Update category relations and counts
Category.remove_category_relation(item_id)
# Update tag relations and counts
Tag.remove_tag_relation(item_id)
# Remove Item
db.session.delete(item)
db.session.commit()
# Update theme author items count
Theme.update_theme_author_count(item_theme_author)
# Update license types count
Theme.update_license_type_count(item_license_type)
return redirect(url_for("home"))
return render_template("theme/theme-single.html",
term_id=term_id,
item_id=item_id,
item=item)
def tag_register():
# data = request.json
# account = data['account']
# password = data['password']
# 1、request.data 会自动传入ClientForm
form = TagForm()
# 2、对TagForm对实例进行校验
if form.validate():
# 3.1、查询标签名是否已经存在
if Tag.query.filter_by(name=form.name.data).first():
# 4、如果标签名存在返回报错601
return ParameterException(error_code=601, msg='标签名已经存在')
else:
# 5、若标签名不存在，尝试注册标签
try:
author = get_account_by_token()
except Exception:
author = 'God'
Tag.add_tag(name=form.name.data,
description=form.description.data,
author=author)
return NoException(msg='注册成功')
else:
# 若form不满足校验规则，返回报错600，后续可以细化
raise ParameterException()
def tag(slug):
"""Retrieve items of the tag"""
tag = Tag.get_item_by_slug(slug)
items = TagRelation.get_items_by_tag_id(tag.id)
tags = Tag.get_items()
return render_template("tag/tag.html", tags=tags, tag=tag, items=items)
def test_get_all(self):
self.load_fixtures()
tag = Tag()
actual = tag.get_all()
expect = [
{'tag_id': 1, 'name': 'ID昇順'},
]
self.assertEqual(expect, actual)
def run(self):
#for i in range(2):
Contributor.fake_feed()
Collective.fake_feed()
Channel.fake_feed()
Tag.fake_feed()
BlogPost.fake_feed()
Podcast.fake_feed()
Section.fake_feed()
Page.fake_feed()
Event.fake_feed()
def tag_add():
form = TagForm(request.form)
if request.method == 'POST' and form.validate():
with db.auto_commit():
tag = Tag()
tag.name = form.name.data
db.session.add(tag)
Oplog('添加标签:' + tag.name)
flash('添加标签成功~', 'ok')
return redirect(url_for('admin.tag_add'))
return render_template('admin/tag_add.html', form=form)
def tags():
posts = Post.query.all()
for post in posts:
name = fake.text(6).replace('.', '')
t = Tag(name=name, posts=[post])
db.session.add(t)
db.session.commit()
def edit_post(id):
post = Post.query.get_or_404(id)
if current_user != post.author and not current_user.can(Permission.ADMIN):
abort(403)
form = PostForm(post=post)
if form.validate_on_submit():
post.title = form.title.data
post.categorys = [
Category.query.filter_by(id=id).first()
for id in form.categorys.data
]
post.body = form.body.data
for name in form.tags.data.split():
tag = Tag.query.filter_by(name=name).first()
if tag is None:
tag = Tag(name=name)
db.session.add(tag)
if tag not in post.tags:
post.tags.append(tag)
for tag in post.tags:
if tag.name not in form.tags.data.split():
db.session.delete(tag)
db.session.add(post)
db.session.commit()
flash('文章修改成功！')
return redirect(url_for('.post', id=post.id))
form.title.data = post.title
form.categorys.data = [category.id for category in post.categorys.all()]
form.tags.data = ' '.join([tag.name for tag in post.tags.all()])
form.body.data = post.body
return render_template('blog/edit_post.html', form=form)
def tag_delete():
meta = {}
ids = request.values.get('ids', '')
type = request.values.get('type', 1)
if not ids:
return jsonify(success=False, message='缺少请求参数!')
try:
arr = ids.split(',')
for d in arr:
tag = Tag.objects(_id=ObjectId(d)).first()
if tag:
is_pass = check_role(tag.role)
if is_pass:
tag.mark_delete() if tag else None
except (Exception) as e:
return jsonify(success=False, message=str(e))
return jsonify(success=True,
message='操作成功!',
data={
'ids': ids,
'type': type
},
redirect_to=url_for('admin.tag_list'))
def tag_edit(tag_id):
"""Edit Tag"""
tag = Tag.get_item_by_id(tag_id)
if tag is None:
abort(404)
else:
if request.method == "POST":
tag.name = request.form["name"]
tag.slug = request.form["slug"]
db.session.add(tag)
db.session.commit()
return render_template("tag/tag-edit.html",
tag=tag,
tags=Tag.get_items())
def result_by_tag(name,page):
all_fragments = Tag.get_fragments_by_tagname(name)
count = len(all_fragments)
PER_PAGE = 1
fragments = all_fragments[(page-1)*PER_PAGE:page*PER_PAGE]
pagination = Pagination(page,PER_PAGE,count)
return render_template("result.html",fragments=fragments,pagination=pagination)
def add_tag_to_article():
request_body = request.get_json()
# user_id = request_body['user_id']
article_id = request_body['article_id']
article_tags = request_body['article_tags']
linked_article = Tag.add_tag_to_article(article_id=article_id,
article_tags=article_tags)
return Success(linked_article)
def tag_delete():
uid = request.get_json()['id']
t = Tag.is_exist(uid=uid)
if t:
u = Tag.query.filter_by(id=uid).first()
u.delete()
return NoException(msg='删除成功')
else:
return ParameterException(msg="查无此人", error_code=602)
def addTags(scopeitem, tags: Iterable):
from app.models import Tag
for tag in tags:
if tag.strip(
) == "": # If the tag is an empty string then don't use it
continue
tag_obj = Tag.create_if_none(tag)
scopeitem.addTag(tag_obj)
def add_tag_to_topic():
request_body = request.get_json()
# user_id = request_body['user_id']
editorial_topic_id = request_body['editorial_topic_id']
editorial_topic_tags = request_body['editorial_topic_tags']
linked_editorial_topic = Tag.add_tag_to_topic(
editorial_topic_id=editorial_topic_id,
editorial_topic_tags=editorial_topic_tags)
return Success(linked_editorial_topic)
def create_tag():
request_body = request.get_json()
# user_id = request_body['user_id']
tag_name = request_body['tag_name']
if 'tag_entity_type' in request_body:
tag_entity_type = request_body['tag_entity_type']
else:
tag_entity_type = 'none'
message = Tag.create_tag(tag_name=tag_name,
tag_entity_type=tag_entity_type)
return message
def add():
"""
添加标签
"""
form = TagForm()
# 判断表单是否为空
if form.validate_on_submit():
data = form.data
tag = Tag.query.filter_by(name=data['name']).count()
log('tag', tag)
# 若标签名称存在， 则返回错误信息
if tag == 1:
flash('标签名称已经存在！', 'err')
return redirect(url_for('tag.add'))
# 若名称不存在， 则添加
else:
tag = Tag(data)
tag.save()
flash('标签添加成功', 'ok')
return redirect(url_for('tag.add'))
return render_template('admin/tag/add.html', form=form)
def tag_add():
"""Register new tag"""
if request.method == "POST":
# Define variables
name = request.form.get('name')
slug = request.form.get('slug')
if slug == "":
slug = slugify(name)
tag_exists = Tag.get_item_by_slug(slug) is not None
if not tag_exists:
# Add new item to database
item = Tag.add(name, slug)
# Redirect to add tag page
return redirect(url_for("tag_add"))
else:
flash('Tag already exists.')
# Render tag-add.html and serve page
return render_template("tag/tag-add.html", tags=Tag.get_items())
def load_tasks(db) -> DBFuncResult:
_SQL = """select id, name from awards_types """
db.exec_sql(_SQL, [])
res = db.cursor.fetchall()
if res:
tags = []
for tag in res:
tags.append(Tag(id=tag[0], name=tag[1]))
return DBFuncResult(tags, True, None, None)
return DBFuncResult(None, False,
"Не удалось получить список тэгов заданий", None)
def create():
form = CreateFragmentForm()
form.branch.choices = Branch.get_all_choices()
form.tags.choices = Tag.get_all_chioces()
fragment = Fragment()
branch_id = form.branch.data
if form.validate_on_submit():
fragment.title = form.title.data
fragment.markdown = form.body.data
fragment.user_id = current_user.id
fragment.branch_id = form.branch.data
tags_id = form.tags.data
tags = Tag.get_by_ids(tags_id)
fragment.tags = tags
fragment.save()
flash('Edit Saved.', category='success')
return redirect(url_for("main.home"))
form.title.data = fragment.title
form.body.data = fragment.markdown
return render_template('editor.html',form=form)
def import_scope_list(address_list: Iterable, blacklist: bool) -> dict:
result = {"fail": [], "success": 0, "exist": 0}
prefixes = {"sqlite": " OR IGNORE", "mysql": " IGNORE"}
selected_prefix = prefixes.get(db.session.bind.dialect.name)
scope_import = {}
scope_tag_import = {}
address_list = [line.strip() for line in address_list]
tags = ScopeItem.extract_import_tags(address_list)
tag_dict = {}
from app.models import Tag
for tag in tags:
tag_dict[tag] = Tag.create_if_none(tag)
db.session.commit()
for line in address_list:
ip, tags = ScopeItem.parse_import_line(line)
if not ip:
result["fail"].append(line)
continue
tags = [tag_dict[tag] for tag in tags]
item = ScopeItem(target=str(ip), blacklist=blacklist).as_dict()
scope_tag_import[item["target"]] = tags
scope_import[item["target"]] = item
import_list = [v for _, v in scope_import.items()]
chunk_size = 10000
import_chunks = [
import_list[i:i + chunk_size]
for i in range(0, len(import_list), chunk_size)
]
for chunk in import_chunks:
ins_stmt = (ScopeItem.__table__.insert().prefix_with(
selected_prefix).values(chunk))
ins_result = db.session.execute(ins_stmt)
result["success"] += ins_result.rowcount
result["exist"] = len(address_list) - len(
result["fail"]) - result["success"]
all_scope = {item.target: item.id for item in ScopeItem.query.all()}
tags_to_import = []
for k, v in scope_tag_import.items():
for tag in v:
tags_to_import.append(
dict(scope_id=all_scope[k], tag_id=tag.id))
import_chunks = [
tags_to_import[i:i + chunk_size]
for i in range(0, len(tags_to_import), chunk_size)
]
for chunk in import_chunks:
tag_stmt = scopetags.insert().prefix_with(selected_prefix).values(
chunk)
db.session.execute(tag_stmt)
db.session.commit()
return result
def add_tag():
# name = request.args.get('name', 0, type=int)
response = {"status": 500, "msg": "name is Null!"}
name = request.form['name']
if name != "":
tag = Tag.add(name)
if tag:
res = {"id": tag.id, "name": tag.name}
response['tag'] = res
response["status"] = 200
else:
response["msg"] = "tag has already exists!"
return make_response(json.dumps(response))
def theme_single(slug):
"""Return an item"""
item = db.session.query(Theme).filter_by(slug=slug).one()
item_categories = db.session.query(CategoryRelation) \
.filter_by(theme_id=item.id).all()
item_tags = db.session.query(TagRelation) \
.filter_by(theme_id=item.id).all()
return render_template("theme/theme-single.html",
item=item,
categories=Category.get_items(),
item_categories=item_categories,
tags=Tag.get_items(),
item_tags=item_tags)
def tag_submit():
meta = metaInit.copy()
meta['referer_url'] = request.environ.get(
'HTTP_REFERER') if request.environ.get('HTTP_REFERER') else ''
id = request.args.get('id', None)
meta['data'] = None
if id:
tag = Tag.objects(_id=ObjectId(id)).first()
meta['data'] = tag
form = SaveForm()
#current_app.logger.debug(id)
return render_template('admin/tag/submit.html', meta=meta, form=form)
def create_question(cid):
course = Course.query.filter_by(cid=cid).first_or_404()
form = QuestionCreateForm().validate_for_api()
with db.auto_commit():
question = Question(title=form.title.data,
content=form.content.data,
course_id=course.cid,
author_gid=g.user['gid'],
update_time=int(datetime.now().timestamp()))
history = History(root_question=question)
for tag_name in form.tags.data:
tag = Tag.get_or_create_tag(tag_name)
question.tags.append(tag)
db.session.add(question, history)
return Success()
def tag_upload():
# form = TagImageForm()
# print(form)
file = request.files.get('file')
form = TagImageForm(data={'file': file})
if form.validate():
img = form.file.data
file_name = uuid.uuid4().hex + '.' + img.filename.split('.')[-1]
path = os.getcwd() + '\\app' + UPLOAD_PATH + '\\' + file_name
img.save(path)
t = Tag.is_exist(tag_id=1)
if t:
u = Tag.query.filter_by(id=1).first()
u.update(icon_url=file_name)
return NoException(msg="上传成功")
else:
return ParameterException(msg="查无此人", error_code=602)
else:
raise ParameterException()
def new_post():
form = PostForm()
if current_user.can(Permission.WRITE) and form.validate_on_submit():
post = Post(title=form.title.data,
body=form.body.data,
categorys=[
Category.query.filter_by(id=id).first()
for id in form.categorys.data
],
author=current_user._get_current_object())
for name in form.tags.data.split():
tag = Tag.query.filter_by(name=name).first()
if tag is None:
tag = Tag(name=name)
db.session.add(tag)
post.tags.append(tag)
db.session.add(post)
db.session.commit()
flash('文章发表成功！')
return redirect(url_for('.post', id=post.id))
return render_template('blog/new_post.html', form=form)
def update_question(qid):
question = Question.query.get_or_404(qid)
form = QuestionUpdateForm().validate_for_api()
with db.auto_commit():
print(form.new_tags.data)
for new_tag_name in form.new_tags.data:
tag = Tag.get_or_create_tag(new_tag_name)
question.tags.append(tag)
for del_tag_name in form.del_tags.data:
tag_set = Tag.query.filter_by(name=del_tag_name)
if tag_set.count():
try:
question.tags.remove(tag_set.first())
except ValueError:
continue
if form.content.data or form.title.data:
if form.content.data != question.content or form.title.data != question.title:
history = History.create_from_question(question)
form.populate_obj(question)
db.session.add(history)
question.author_gid = g.user['gid']
question.update_time = int(datetime.now().timestamp())
return Success()
def setUp(self):
self.tag = Tag("Groceries")
