def load_categories():
"""Load categories infomation."""
clothing = Category(cg_name='clothing')
shoes = Category(cg_name='shoes')
db.session.add(clothing)
db.session.add(shoes)
db.session.commit()
def category_add():
if request.method == 'POST':
new_category = Category(name=request.form['name'],
description=request.form['description'],
user_id=login_session['user_id'])
picture = request.files['category-pic']
if picture and allowed_file(picture.filename):
filename = secure_filename(picture.filename)
extension = os.path.splitext(filename)[1]
unique_filename = str(uuid.uuid4()) + str(extension)
picture.save(
os.path.join(app.config['UPLOAD_FOLDER'], unique_filename))
new_category.picture = unique_filename
session.add(new_category)
session.commit()
return redirect(url_for('category_view'))
else:
categories = session.query(Category).all()
return render_template('add_category.html', categories=categories)
def make_categories():
""" Let's make some categories! """
print 'Making Categories...'
# Let's delete the table in case I want to redo this
Category.query.delete()
category_dict = {'opr': 'Operations',
'mar': 'Marketing',
'mds': 'Markdowns',
'vix': 'Visual Merchandising',
'pro': 'Promotions',
'evt': 'Events',
'hrp': 'Human Resources/Payroll',
'mis': 'Miscellaneous'}
for category in category_dict:
cat_id = category
name = category_dict[category]
category_obj = Category(cat_id=cat_id, name=name)
db.session.add(category_obj)
db.session.commit()
def load_categories():
"""Load users from categories.csv into database"""
print "Categories"
# Delete all rows in table, so if we need to run this a second time,
# we won't be adding duplicate categories
Category.query.delete()
# Read category.csv file and insert data
for row in open("seed_data/categories.csv"):
row = row.rstrip()
cat_id, name, screenname, img_url = row.split(",")
category = Category(cat_id=cat_id,
name=name,
screenname=screenname,
img_url=img_url)
# Need to add to session to store
db.session.add(category)
# Commit my work
db.session.commit()
def admin_page():
url_for('static', filename='style.css')
all_categories = Category.query.all()
all_users = User.query.all()
if request.method == "POST":
if "add-category" in request.form:
category = Category(name=request.form["category-name"])
all_categories.append(category)
database.session.add(category)
elif "delete-category" in request.form:
Category.query.filter_by(
id=int(request.form["delete-category"])).delete()
elif "add-user" in request.form:
user = users.create(request.form["user-login"],
request.form["user-password"],
request.form["user-first-name"],
request.form["user-last-name"], "user-is-admin"
in request.form)
all_users.append(user)
database.session.add(user)
elif "delete-user" in request.form:
User.query.filter_by(login=request.form["delete-user"]).delete()
database.session.commit()
return render_template('admin.html',
categories=all_categories,
users=all_users,
is_admin=True)
def load_categories():
"""Load categories into categories table."""
data = pd.read_csv("Diversitech-Table.csv")
print "Categories"
categories = data.columns.values
for index, row in data.iterrows():
for i in range(len(row[5:21])):
if row[i + 5] == "-":
continue
else:
category = categories[i + 5]
percentage = row[i + 5]
name = row[0]
name_lower = name.lower()
company = Company.query.filter(
Company.name == name_lower).first()
id_of_company = company.company_id
detail = Category(category=category,
percentage=percentage,
company_id=id_of_company)
db.session.add(detail)
db.session.commit()
def loadCategory():
"""look for the category names in the csv file and load the table categories"""
category_names_set = set()
list_categories = [
'Human Trafficking (A), Commercial Sex Acts', 'Civil Sidewalks',
'Gambling', 'Motor Vehicle Theft', 'Drug Offense', 'Rape',
'Prostitution', 'Homicide', 'Robbery', 'Drug Violation', 'Burglary',
'Sex Offense', 'Offences Against The Family And Children',
'Weapons Offense', 'Stolen Property', 'Larceny Theft', 'Assault',
'Human Trafficking, Commercial Sex Acts', 'Warrant',
'Weapons Carrying Etc', 'Family Offense', 'Weapons Offence',
'Malicious Mischief', 'Vehicle Impounded'
]
for index in range(total_rows):
category_name_row = data.iloc[index][14]
if str(category_name_row).strip() in list_categories:
category_names_set.add(category_name_row)
list_categories = list(category_names_set)
for i in range(len(list_categories)):
category_instance = Category(category_name=list_categories[i],
count_crime=0)
db.session.add(category_instance)
db.session.commit()
print("Category table is loaded")
def load_user_categories():
"""Load user categories from seed-user-category.txt into database."""
print("User Categories")
# Delete all rows in table, so if we need to run this a second time,
# we won't be trying to add duplicate users
Category.query.delete()
# Read seed category file and insert data
for row in open("seed/seed-user-category-2.txt"):
row = row.rstrip()
# Works for original seed data
# user_id, base_category_id, name, description = row.split("|")
# These are metadata lines in the file
if not row.startswith('--'):
category_id, name, description, user_id, base_category_id = row.split(
"|")
category = Category(category_id=int(category_id),
name=name,
description=description,
user_id=int(user_id),
base_category_id=base_category_id)
db.session.add(category)
db.session.commit()
async def api_create_category(request, *, name):
check_admin(request)
if not name or not name.strip():
raise APIValueError('name', 'name cannot be empty.')
category = Category(name=name.strip())
await category.save()
return category
async def api_create_category(request, *, name):
if request.__user__ is None or not request.__user__.admin:
raise APIPermissionError('Only admin can do this!')
if not name or not name.strip():
raise APIValueError('name', 'Name can not be empty.')
cat = Category(name=name.strip())
await cat.save()
return cat
def create_category(session: helpers.extend.session, user: hug.directives.user,
response, warehouse_id: int, name):
"""Creates a category"""
return helpers.do_in_warehouse(
"category",
queries.with_editor_role(
queries.user_warehouse(session, user, warehouse_id)),
lambda warehouse: Category(warehouse=warehouse, name=name))
def new_category():
if request.method == 'POST':
category = Category(name=request.form['category'])
db.session.add(category)
db.session.commit()
return redirect('/')
else:
return render_template('new-category.html', page='new-category.html')
def load_categories():
"""Load real categories into database."""
print "Categories"
Category.query.delete()
# from eventbrite
eb_file = open('seed_data/eb_categories.json')
eb_dict = loads(eb_file.read())
eb_cats = eb_dict['categories']
print eb_cats
for cat in eb_cats:
print 'EB: ', cat
cat_id = cat['id']
name = cat['name']
short_name = cat['short_name']
src_id = 'evtb'
eb_cat_row = Category(cat_id=cat_id,
name=name,
short_name=short_name,
src_id=src_id)
db.session.add(eb_cat_row)
# from meetup
mu_file = open("seed_data/mu_categories.json")
mu_dict = loads(mu_file.read())
mu_cats = mu_dict['results']
print mu_cats
for cat in mu_cats:
print 'MU: ', cat
cat_id = cat['id']
name = cat['name']
short_name = cat['shortname']
src_id = 'mtup'
mu_cat_row = Category(cat_id=cat_id,
name=name,
short_name=short_name,
src_id=src_id)
db.session.add(mu_cat_row)
db.session.commit()
def create_category(user_id, label):
"""Create and return a new category"""
category = Category(user_id=user_id, label=label)
db.session.add(category)
db.session.commit()
return category
def create_category(code, name):
"""Create and return a new category."""
category = Category(cat_code=code, name=name)
db.session.add(category)
db.session.commit()
return category
def create_category(category_name):
"""Create and return category name to seed data"""
category_name = Category(category_name=category_name)
db.session.add(category_name)
db.session.commit()
return category_name
def create_category(name, atlas_id=None):
"""Create and return a new gaming category"""
category = Category(name=name, atlas_id=atlas_id)
db.session.add(category)
db.session.commit()
return category
def add_categories_to_db():
"""Add all categories alias to database."""
for alias in get_categories_alias():
category = Category(cat_name=alias)
db.session.add(category)
db.session.commit()
def create_category(category_name):
"""Create and return a new category"""
category = Category(category_name=category_name)
db.session.add(category)
db.session.commit(category)
return category
def createCategory(category_title, category_descr, category_user_id):
try:
category = Category(title=category_title,
description=category_descr,
user_id=category_user_id)
session.add(category)
session.commit()
except Exception as err:
return err
def create_category(category):
"""Create and return a new category instance"""
new_category = Category(id=category)
db.session.add(new_category)
db.session.commit()
return new_category
def _create_structure():
category = Category('test category', 'category test', 'test_category')
category.meta = {'id': 1, 'webtranslateit_ids': {'content': 1}}
section = Section(category, 'test section', 'section test', 'test_section')
section.meta = {'id': 2, 'webtranslateit_ids': {'content': 2}}
category.sections.append(section)
article = Article(section, 'test article', 'article body', 'test_article')
article.meta = {'id': 3, 'webtranslateit_ids': {'content': 3, 'body': 4}}
section.articles.append(article)
return category, section, article
def createall():
"Creates database tables"
db.create_all()
from model import Category
for i in range(len(CATALOG)):
item = Category()
item.id = i + 1 # item.id 不能为0，所以必须从1 开始
item.category_name = CATALOG[i]
db.session.add(item)
db.session.commit()
def add_category_to_db():
"""Add categories to the database."""
for category in categories:
cat_id = categories[category]['cat_id']
cat_title = categories[category]['cat_title']
cat = Category(cat_id=cat_id, cat_title=cat_title)
db.session.add(cat)
db.session.commit()
def get_items_by_id(item_id):
try:
result = session.query(Item).filter_by(id=item_id).first()
cat_data = (session.query(Category).filter_by(
id=result.category_item_fkey).first())
category = Category(name=cat_data.name)
return jsonify(items=result.serialize_item_details,
category=category.name)
except:
return jsonify(message="error")
def v_add_ca():
try:
new_name = request.form.get('name')
user_id = current_user.id
ca = Category(category_name=new_name, user_id=user_id)
db.session.add(ca)
db.session.commit()
return redirect(url_for('auth.v_arrange', flag='Category'))
except Exception, e:
print e
abort(404)
def create_category(category_name, category_description):
"""Create and return a new category."""
category = Category(category_name = category_name,
category_description = category_description,
)
db.session.add(category)
db.session.commit()
return category
def post_categories(tag):
"""Adds new categories to db that are unique."""
new_category = Category(tag=tag)
db.session.add(new_category)
print 'posted', tag
try:
db.session.commit()
return new_category
except exc.IntegrityError:
db.session.rollback()
print "{} already exists in the Category table.".format(tag)
def create_category(category_name, api_id, category_image):
"""Create and return a category."""
category = Category(category_name=category_name,
api_id=api_id,
category_image=category_image)
db.session.add(category)
db.session.commit()
return category
def load_category():
category_result_list = call_api('exercisecategory')
for result_dict in category_result_list:
category_id = result_dict['id']
category_name = result_dict['name']
category = Category(category_id=category_id,
category_name=category_name)
db.session.add(category)
db.session.commit()
