class CategoryView():
def __init__(self):
"""Class initialization."""
self.model = Category()
def display(self):
"""Method used to display page in terminal."""
self.model.get_page()
clear()
print("Sélectionnez la catégorie:\n")
for category in self.model.categories_list:
print(category[0], "-", category[1])
self.footer()
def footer(self):
"""Method used to display page footer."""
print(f"\nPage {self.model.page}/{self.model.max_pages}")
print(f"[p-1 à p-{self.model.max_pages}] Aller à la page")
print("[n] Page suivante")
print("[b] Page précédente")
print("[1-9999] Sélectionner la catégorie")
print("[q] Quitter l'application")
def editItem(item_id):
item = Item.getItemById(item_id)
if not item:
flash("Item () note found").form(item_id)
return redirect(url_for(main.homepage))
next = get_redirect_target()
form = ItemForm(next=next)
form.category.choices = [(category.id, category.name)
for category in Category.getAll()]
if request.method == 'GET':
form.name.data = item.name
form.description.data = item.description
form.category.data = item.category_id
form.category.choices = [(category.id, category.name)
for category in Category.getAll()]
return render_template('item_form.html',
form=form,
name=item.name,
description=item.description,
category=item.category)
if form.validate_on_submit():
item.name = form.data['name']
item.description = form.data['description']
cat_id = form.data['category']
item.category_id = form.data['category']
db.session.commit()
return redirect_back('main.homepage')
def setUp(self):
self.collection = CategoriesCollection()
for category_name, category_items in self.CATEGORIES.items():
category = Category(category_name)
for raw_item in category_items:
category.add_item(CategoryItem(raw_item))
self.collection.add_category(category)
def create_category(self):
"""Helper function creates category for tests"""
category = Category(user_id=1,
cat_name=self.test_category_name,
description=self.test_category_description)
category.add()
def create_category():
jsonData = request.get_json()
with db.auto_commit():
category = Category()
category.category_name = jsonData['category_name']
db.session.add(category)
return Success(msg='新增赛事类型成功')
def edit_category(id):
form = CategoryForm.AddForm()
if form.validate_on_submit():
category = Category()
if (category.is_exist(id) != True):
flash('Sorry,That category doesn\'t exist',
category='errorMessage')
return redirect(redirect_back())
if category.exist_twice(request.form['name']):
flash('Sorry,There is another category with the same name',
category='errorMessage')
return redirect(redirect_back())
save_category = category.update(request.form['name'], id)
if (save_category):
flash(' Category \'{0}\' has been successfully updated'.format(
category.name),
category='successMessage')
return redirect(redirect_back())
flash('Unable to save category', category='errorMessage')
flash(request.form, category='input')
return redirect(redirect_back())
error = form.errors
flash(error, category='error')
flash(request.form, category='input')
return redirect(redirect_back())
def get(cid):
model = Category.get_model_with_img(cid, throw=True)
mini_image = File.get(one=True, id=model.mini_img_id)
if mini_image:
model.mini_image = Category.get_file_url(mini_image.path)
model._fields.append('mini_image')
return jsonify(model)
def add_category(name):
cate = Category(name=name)
cate.create_time = 1
db.session.add(cate)
result = db.session.commit()
return redirect(url_for('index'))
def post(self):
'''Creates a new Category '''
data = request.get_json()
categoryName = data.get('category_name')
categoryDesc = data.get('category_description')
catName_validator = name_validate(categoryName)
catDesc_validator = name_validate(categoryDesc)
if catName_validator is False:
return {"message": "category name cannot be blank"}, 422
if catDesc_validator is False:
return {
"message":
"category description cannot be blank, please"
" enter a valid description"
}, 422
user_id = get_jwt_identity()
if Category.query.filter_by(
user_id=user_id,
category_name=categoryName).first() is not None:
return {'message': 'Category already exists'}, 409
new_cat = Category(categoryName, categoryDesc, user_id)
new_cat.save()
return {
'category_id': new_cat.category_id,
'message': 'Category successfully created'
}, 201
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 fake_categories(nums=5):
with db.auto_commit():
# 优先生成默认分类
data = Category(name='default')
db.session.add(data)
for i in range(nums):
data = Category(name=faker.word())
db.session.add(data)
def create_category():
"""Create a category"""
name = request.json.get("name", '')
if not name:
return bad_request(405)
category = Category(name=name)
category.save()
return jsonify(category.to_dict()), 201
def test_add_category(self):
f = Collection(name='Testcollection')
c = Category(name='Test')
f.categories.append(c)
self.assertTrue(f.categories.count() == 1)
c2 = Category(name='New')
f.categories.append(c2)
self.assertTrue(f.categories.count() == 2)
def category_list():
meta = {
'title': '分类管理',
'css_nav_sub_category': 'active',
'css_nav_system': 'active'
}
query = {}
page = int(request.args.get('page', 1))
per_page = int(request.args.get('per_page', 100))
status = int(request.args.get('status', 0))
kind = int(request.args.get('kind', 0))
deleted = int(request.args.get('deleted', 0))
if kind:
query['kind'] = kind
if kind == 1:
meta['css_doc'] = 'active'
elif kind == 2:
meta['css_other'] = 'active'
else:
meta['css_all'] = 'active'
else:
meta['css_all'] = 'active'
if status == -1:
query['status'] = 0
elif status == 1:
query['status'] = 1
else:
pass
query['deleted'] = deleted
page_url = url_for('admin.category_list',
page="#p#",
status=status,
kind=kind,
per_page=per_page)
data = Category.objects(**query).order_by('-created_at').paginate(
page=page, per_page=per_page)
total_count = Category.objects(**query).count()
# 过滤数据
for i, d in enumerate(data.items):
kind_label = '--'
if d.kind == 1:
kind_label = '文档'
if d.kind == 2:
kind_label = '备用'
data.items[i].kind_label = kind_label
meta['data'] = data.items
pager = Pager(page, per_page, total_count, page_url)
meta['pager'] = pager.render_view()
return render_template('admin/category/list.html', meta=meta)
def setUp(self):
self.category = Category(self.CATEGORY_NAME)
self.items = {
item_name: CategoryItem(item_name)
for item_name in self.CATEGORY_ITEMS
}
for category_item in self.items.values():
self.category.add_item(category_item)
def update_item():
"""
Update the requested item.
"""
# Get the category and check if it's exist or fail to 404 page if not
category = Category.find_or_fail(request.form['category_id'])
# Get the item and check if it's exist or fail to 404 page if not
item = Item.find_or_fail(request.form['item_id'])
# Make sure the current user is authorized or not
if not item.user or item.user.id != current_user.id:
return current_app.login_manager.unauthorized()
# The below is for validate the unique slug, if it
# was exists before, then the ORM will not fall to
# the ModelNotFound exception and the code will
# continue flashing the error message to the user.
# Otherwise, if the slug is not exists, then the
# request is completely valid and the ORM will
# going to fall to the ModelNotFound exception
# then save the new Item
try:
# Get the current item slug before it changing using ORM mutator
old_item_slug = item.slug
item.title = request.form['title']
item.description = request.form['description']
# Associate the new item with the category
item.category().associate(category)
# Associate the new item to the current user
item.user().associate(current_user)
# Get the item and check if it's exist or fail to 404 page if not
Item.where('slug', item.slug).first_or_fail()
# if the current slug is the same as requested then throw
# to the ModelNotFound Exception and save the current item
if item.slug == old_item_slug:
raise ModelNotFound(item.__class__)
flash('The title seems similar to another'
' title, please choose another one.')
return render_template('items/edit.html',
categories=Category.all(),
item=item)
except ModelNotFound:
# Save the item
item.save()
return redirect(
url_for('view_item', category_slug=category.slug, item_slug=item.slug))
def category(slug):
"""Retrieve items of the category"""
category = Category.get_item_or_404(slug)
categories = Category.get_items()
items = CategoryRelation.get_items_by_category_id(category.id)
return render_template("category/category.html",
categories=categories,
category=category,
items=items)
def setUp(self):
"""
Sets up tests Category object :
Category(categorytitle, categorydescription)
The constructor of the Category class is;
self.categorytitle = categorytitle
self.categorydescription = categorydescription
"""
self.sample_category = Category('Kenyan dishes',
'Dishes made in Kenya')
def get_category(category_id=None):
"""
Return a JSON version of the category.
:param category_id:
:return: Response
"""
try:
category = Category.by_id(category_id)
except Exception:
return jsonify(Category.all())
else:
return jsonify(category.to_dict())
def test_from_and_to_dict(self):
category = utl.CATEGORIES[-1]
c = Category()
# Test using the from_dict() method
c.from_dict(category)
self.assertEqual(c.name, category["name"])
self.assertEqual(c.units, category["units"])
# Test using the to_dict() method
c_dict = c.to_dict()
self.assertEqual(c_dict["name"], category["name"])
self.assertEqual(c_dict["units"], category["units"])
def add_item(category_slug=None):
"""
Add a new Item Form.
:param category_slug: The category slug
"""
# Get the current category using the slug
current_category = Category.where('slug', category_slug).first()
return render_template('items/add.html',
categories=Category.all(),
current_category=current_category)
def test_category_items(self):
dbf.category_init()
dbf.item_init()
for c in dbf.category_list:
c_id = Category.getIdByName(c)
rv = self.client.get('/category/' + str(c_id))
for i in dbf.item_list:
i_c_id = Category.getIdByName(i.get('category'))
if i_c_id == c_id:
self.assertTrue(i.get('name') in rv.get_data(as_text=True))
else:
self.assertFalse(
i.get('name') in rv.get_data(as_text=True))
def delete_category(id):
category = Category()
if (category.is_exist(id) != True):
flash('Sorry,That category doesn\'t exist', category='errorMessage')
return redirect(redirect_back())
delete_category = category.delete(id)
if (delete_category):
flash(' Category has been successfully deleted',
category='successMessage')
return redirect(redirect_back())
flash('Unable to save category', category='errorMessage')
flash(request.form, category='input')
return redirect(redirect_back())
def do_add_category(user_id):
category = Category(
user_id=int(user_id),
cat_name=valid_data['category_name'],
description=valid_data['category_description'],
)
category.add()
return jsonify({
'id': category.cat_id,
'category_name': category.cat_name,
'category_description': category.cat_description,
'category_date': category.cat_date,
'message': 'category created'
}), 201
def get(self, category_id):
"""
Delete a category by id
Args:
category_id: category's id
Returns:
A flask redirect.
"""
Category.delete_by_id(category_id)
flash('Category has been deleted.', 'success')
return redirect(url_for('home'))
def addSamples():
kategoriat = ['emolevyt', 'suorittimet', 'muistit']
if not len(Category.get()):
Category(name=kategoriat[0]).put()
Category(name=kategoriat[1]).put()
Category(name=kategoriat[2]).put()
while not len(Category.get()):
sleep(1)
emolevy = Category.get(name=kategoriat[0])[0]
suoritin = Category.get(name=kategoriat[1])[0]
muistit = Category.get(name=kategoriat[2])[0]
else:
emolevy = Category.get(kategoriat[0])[0]
suoritin = Category.get(kategoriat[1])[0]
muistit = Category.get(kategoriat[2])[0]
Product(name="Asus Z87-K Intel Z87 LGA 1150 ATX-emolevy.", description="Kuvaus", price=118.90, category = emolevy).put()
Product(name="AMD A8 5600K 3.6 GHz", description="FM2-kantaan", price=100, category=suoritin).put()
Product(name="AMD A6 6400K Black Edition 4.1 GHz", description="FM2-kantaan", price=70, category=suoritin).put()
Product(name="AMD A10 6800K Black Edition 4.4 GHz", description="FM2-kantaan", price=150, category=suoritin).put()
Product(name="AMD A8 6600K Black Edition 4.3 GHz", description="FM2-kantaan", price=110, category=suoritin).put()
Product(name="Intel Core i5 4670K 3.4 GHz LGA1150", description="Intelin uuteen LGA1150-kantaan suunniteltu suoritin Haswell -arkkitehtuurilla.", price=250, category=suoritin).put()
Product(name="Intel Core i7 4770K 3.5 GHz LGA1150", description="Intelin uuteen LGA1150-kantaan suunniteltu suoritin Haswell -arkkitehtuurilla.", price=350, category=suoritin).put()
Product(name="Intel Core i5 4430 3.0 GHz LGA1150", description="Intelin uuteen LGA1150-kantaan suunniteltu suoritin Haswell -arkkitehtuurilla.", price=200, category=suoritin).put()
Product(name="Intel Core i5 4570 3.2 GHz LGA1150", description="Intelin uuteen LGA1150-kantaan suunniteltu suoritin Haswell -arkkitehtuurilla.", price=210, category=suoritin).put()
Product(
name="Kingston ValueRam 4 GB 1333 MHz DDR3 SO-DIMM CL9 -muistikampa.",
description="DDR3 SO-DIMM CL9",
price=42.90,
category=muistit
).put()
def dbcreate():
db.create_all()
client = Client("Placeholder Client")
category = Category("Placeholder Category")
client.save()
category.save()
client_id = client.id
category_id = category.id
feature = Feature("Demo Feature", "Demo Feature Description", 1, client_id,
category_id, datetime(2018, 1, 1))
feature.save()
class TestCategory(unittest.TestCase):
CATEGORY_ITEMS = [
"рецепт борща", "яблочный пирог", "пирог яблочный", "тайская кухня"
]
CATEGORY_NAME = "кухня"
def setUp(self):
self.category = Category(self.CATEGORY_NAME)
self.items = {
item_name: CategoryItem(item_name)
for item_name in self.CATEGORY_ITEMS
}
for category_item in self.items.values():
self.category.add_item(category_item)
def testSearchItems(self):
cases = [{
"queries": [
"рецепт борща", "точный рецепт борща", "рецепт вкусного борща",
"срочно! где найти рецепт борща?"
],
"expect": [self.items["рецепт борща"]]
}]
for test_case in cases:
for query in test_case['queries']:
self.assertListEqual(self.category.search_items(query),
test_case['expect'])
def testSearchItemsMany(self):
cases = [{
"queries":
["яблочный пирог", "пирог яблочный", "большой яблочный пирог"],
"expect": {
"пирог яблочный": self.items["пирог яблочный"],
"яблочный пирог": self.items["яблочный пирог"]
}
}]
for test_case in cases:
for query in test_case['queries']:
self.assertDictEqual(
{
item.name: item
for item in self.category.search_items(query)
}, test_case['expect'])
def init(username, password):
"""初始化数据库 admin 分类"""
click.echo('初始化数据库中...')
db.create_all()
with db.auto_commit():
admin = Admin.query.first()
if admin is not None:
click.echo('管理员账号已存在,更新中...')
admin.username = username
admin.set_password(password)
else:
click.echo('创建默认管理员数据中...')
admin = Admin(
username=username,
blog_title='Br Blog',
blog_sub_title="Genius only means hard-working all one's life.",
name='Jack Zhang',
about='''永不放弃是人生要成功的一大因素，
只要能够坚持，
锲而不舍，
终会到达成功的彼岸的。'''
)
admin.set_password(password)
db.session.add(admin)
category = Category.query.first()
if category is None:
click.echo('创建默认分类...')
category = Category(name='Default')
db.session.add(category)
click.echo('Done.')
def mutate(root, info, question_data):
errors = {}
current_user = get_jwt_identity()
user = UserModel.find_by_id(current_user["id"])
if not user:
errors["user"] = "******"
category = CategoryModel.find_by_id(question_data["category_id"])
if not category:
errors["category"] = "not found"
location = CityModel.find_by_id(question_data["location_id"])
if not location:
errors["location"] = "not found"
if errors:
raise GraphQLError(json.dumps(errors))
del question_data["category_id"]
del question_data["location_id"]
question = QuestionModel(created_by=user,
category=category,
location=location,
**question_data)
question.save()
return CreateQuestion(question=question, ok=True)
def post(self):
form = NormalForm()
categories = Category.objects()
if form.validate_on_submit():
product = Product(seller_id=current_user.id,
name=form.name.data,
price=form.price.data,
detail=form.detail.data,
image="product." +
form.image.data.filename.split(".")[1].lower(),
categories=request.form.getlist("categories"),
bidding=False,
status=0)
product.save()
image_path = os.path.join(os.getcwd(), 'app/static/image',
str(product.id))
os.makedirs(image_path)
form.image.data.save(os.path.join(image_path, product.image))
return redirect(url_for('user.profile'))
return render_template('user/selling/normal.html',
form=form,
categories=categories)
def post_category():
"""
Insert shopping_list
"""
data = request.get_json(silent=True)
print(data)
if 'name' in data and 'description' in data and 'slug' in data:
name = data['name']
description = data['description']
slug = data['slug']
Category.create(name=name, description=description, slug=slug)
return make_response(jsonify({'success': True, 'result': 'Category Created'}), 201)
else:
return make_response(jsonify({'success': False, 'result': 'Incomplete parameters'}), 400)
def list(self):
try:
category = self.request.params['category']
except KeyError:
category = None
if category is None or not len(Category.get(name=category)):
category = 'suorittimet'
self.set(category = category)
self.template_name = 'products/list.html'
self.set(tuotteet = Product.get(category = Category(name=category)))
def add(title, desc, father, icon):
assert isinstance(title, basestring), 'title is not string'
assert isinstance(desc, basestring), 'title is not string'
assert len(title) > 0, 'title name too short!'
assert len(desc) > 5, 'desc name too short!'
assert father is None or isinstance(father, ObjectId)
if father:
assert CategoryHelper.get(father)
new_category = Category()
new_category.title = title
new_category.desc = desc
if father:
new_category.father = father
if icon:
encoded = b64encode(icon.read())
new_category.icon.new_file()
new_category.icon.write(encoded)
new_category.icon.close()
new_category.save()
if father:
CategoryHelper.add_son(father, new_category.id)
return new_category
def get_category(id):
"""
Fetch shopping_list
"""
query = Category.objects(user_id=int(id))
if query.count > 0:
data = {'results': []}
i = 0
for instance in query:
data['results'].append({'id': instance.id,
'name': instance.name,
'slug': instance.slug,
'description': instance.description,
'created_at': instance.created_at})
i += 1
if i == query.count():
return make_response(jsonify({'success': True, 'results': data['results']}), 200)
else:
return make_response(jsonify({'success': True, 'results': []}), 204)
def delete_route(route_id):
assert isinstance(route_id, ObjectId)
route = RouteHelper.get(route_id)
assert route
for attach_id in route.attached:
AttachmentHelper.delete(attach_id)
f_cate = Category.objects(id=route.father).first()
f_cate.routes.remove(route.id)
f_cate.save()
enters = EnteredRoute.objects(route=route.id)
for entered_route in enters:
user = UserHelper.get(entered_route.user)
user.entered_routes.remove(route.id)
user.save()
enters.delete()
RateInfo.objects(route=route.id).delete()
route.delete()
#!/usr/bin/python
# -*- coding: utf-8 -*-
from urllib import *
from app.app import app
from app.models.category import Category
from app.helpers.category import CategoryHelper
Category.objects().delete()
program_icon = urlopen('http://www.pronovadesigns.com/wp-content/uploads/2014/03/web-programming1.jpg')
c_icon = urlopen('https://upload.wikimedia.org/wikipedia/commons/6/6f/Cimage.jpg')
cpp_icon = urlopen('http://avatar.csdn.net/blogpic/20140408151827593.jpg')
mfc_icon = urlopen('http://gaitaobao2.alicdn.com/tfscom/i4/T1BrgMXc0XXXXXXXXX_!!0-item_pic.jpg_310x310.jpg')
cocos2dx_icon = urlopen('http://avatar.csdn.net/blogpic/20120103185816438.jpg')
java_icon = urlopen('http://www.theinquirer.net/IMG/935/317935/java-logo-oracle-20-years-programming.jpg')
python_icon = urlopen('http://www.anxia.com/uploads/image/201501/291422523242436140.jpg')
art_icon = urlopen('https://cbsmiami.files.wordpress.com/2012/10/art-paint-jpg.png?w=300')
music_icon = urlopen('http://www.christchurchkennebunk.org/musicstaff.jpg')
sing_icon = urlopen('http://static.wixstatic.com/media/af2255_96fb29987ba64150b6c679f282b65cd0.jpg_256')
instrument_icon = urlopen('http://www.thecoolhunter.net/images/stories/2007pics/storiesnew2007pics/marchpics/1music.jpg')
painting_icon = urlopen('http://www.iconshock.com/img_jpg/PERSPECTIVE/general/jpg/256/paint_icon.jpg')
root_program = CategoryHelper.add(u'编程语言', u'编程语言（programming language），是用来定义计算机程序的形式语言。它是一种被标准化的交流技巧，用来向计算机发出指令。一种计算机语言让程序员能够准确地定义计算机所需要使用的数据，并精确地定义在不同情况下所应当采取的行动', None, program_icon)
c = CategoryHelper.add(u'C语言', u'C是一种通用的编程语言，广泛用于系统软件与应用软件的开发。于1969年至1973年间，为了移植与开发UNIX操作系统，由丹尼斯·里奇与肯·汤普逊，以B语言为基础，在贝尔实验室设计、开发出来。', root_program.id, c_icon)
cpp = CategoryHelper.add(u'C++', u'C++是一种广泛使用的计算机程序设计语言。它是一种通用程序设计语言，静态数据类型检查，支持多重编程范式，例如过程化程序设计、数据抽象化、面向对象程序设计、泛型程序设计、基于原则设计等。', root_program.id, cpp_icon)
mfc = CategoryHelper.add(u'MFC', u'微软基础类库（英语：Microsoft Foundation Classes，简称MFC）是一个微软公司提供的类库（class libraries），以C++类的形式封装了Windows API，并且包含一个应用程序框架，以减少应用程序开发人员的工作量。其中包含的类包含大量Windows句柄封装类和很多Windows的内建控件和组件的封装类。', cpp.id, mfc_icon)
cocos2dx = CategoryHelper.add(u'Cocos2d-x', u'Cocos2d-x是一个开源的移动2D游戏框架，MIT许可证下发布的。这是一个C++ Cocos2d-iPhone项目的版本。Cocos2d-X发展的重点是围绕Cocos2d跨平台，Cocos2d-x提供的框架。手机游戏，可以写在C++或者Lua中，使用API是Cocos2d-iPhone完全兼容。', cpp.id, cocos2dx_icon)
java = CategoryHelper.add(u'Java', u'Java是一种计算机编程语言，拥有跨平台、面向对象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。', root_program.id, java_icon)
def get_hot_categorys():
return Category.objects()[:6]
def get(category_id):
return Category.objects(id=category_id).first()
def get_by_title(title):
return Category.objects(title__startswith=title).first()
def get_roots():
return Category.objects(father__exists=False)
def get_all_categories(): categories = Category.get_all_categories() return Success(categories)
