def init_db():
import models
Base.metadata.create_all(bind=engine)
cat1 = models.Category('DOm')
cat2 = models.Category('kot')
cat3 = models.Category('pies')
db_session.add(cat1)
db_session.add(cat2)
db_session.add(cat3)
db_session.commit()
def add_category_handler(catalog_id):
"""Adds a category to a catalog
Parameters:
- catalog_id: integer id of catalog to which category belongs
Returns:
- HTTP response
"""
user = models.get_current_user()
catalog_id = int(catalog_id)
catalog_entity = models.get_catalog_by_id(catalog_id)
# Check parameters
if not catalog_entity:
raise BadRequest('Could not find catalog with id %d' % catalog_id)
if not catalog_entity.user_can_edit(user):
raise Unauthorized
if flask.request.method == 'GET':
# Render add category form
return flask.render_template('addcategory.html',
user=user,
catalog=catalog_entity,
category=None)
elif flask.request.method == 'POST':
# Handle new category submission from form
new_category = models.Category(
name=flask.request.form.get('name'),
description=flask.request.form.get('description'),
catalog=catalog_entity.key)
new_category.put()
models.wait_for(new_category)
return flask.redirect('/catalog/%d' % catalog_entity.key.id())
def load_one_item(owner):
item_test_data = items_data_list[0]
it = models.Item.query(
models.Item.place_name == item_test_data[ITEM_NAME]).get()
if it:
return it
else:
new_it = models.Item()
cat = models.Category.get_by_id(item_test_data[ITEM_CATEGORY])
if not cat:
cat = models.Category(id=item_test_data[ITEM_CATEGORY]).put()
new_it.category = cat
new_it.place_name = item_test_data[ITEM_NAME]
home = geo.LatLng(lat=51.57, lng=-0.13)
lat_long = geo.geoCodeAddress(item_test_data[1], home)
new_it.lat = lat_long['lat']
new_it.lng = lat_long['lng']
new_it.address = item_test_data[ITEM_ADDRESS]
new_it.owner = owner.key.integer_id()
# new_it.descr = "blah"
new_it.geo_hash = geohash.encode(new_it.lat, new_it.lng)
img = models.DBImage()
detail = geo.getPlaceDetailFromGoogle(new_it)
img.remoteURL = detail['photo']
img.put()
new_it.photo = img
new_it.telephone = detail['telephone']
new_it.put()
return new_it
def create_category(db: Session, category: schemas.CategoryCreate):
db_category = models.Category(name=category.name,
description=category.description)
db.add(db_category)
db.commit()
db.refresh(db_category)
return db_category
def recommend():
reponame = request.form.get('reponame')
repo = models.Repo.get(name=reponame)
if not repo:
return flask.jsonify(
dict(status=2, message='repo %s not found' % reponame))
author = request.form.get('email')
reason = request.form.get('reason')
category = request.form.get('category')
rc = models.Recommend.get(repo=repo)
print rc
if rc:
return flask.jsonify(
dict(status=1, message='Already recommend by %s' % (rc.author)))
rc = models.Recommend(repo=repo, author=author, reason=reason)
rc.name = repo.name
rc.created = datetime.datetime.today()
rc.updated = datetime.datetime.today()
rc.checked = False
rc.uuid = '%s-%s' % (uuid.uuid4(), uuid.uuid1())
cg = models.Category.get(name=category) or \
models.Category(name=category)
rc.category = cg
print author, reason
return flask.jsonify(
dict(status=0,
message='Thanks, Email will send to you after checked.'))
def addCategory(domain, category_name, category_description):
key = removeSpacesInString(category_name)
row = models.Category(key_name=key)
row.category_domain = domain
row.category_name = category_name
row.category_description = category_description
row.put()
def save_to_db(db_file, store):
engine = create_engine('sqlite:///{}'.format(db_file))
Session = sessionmaker(bind=engine)
# Initialize DB if needed
if not os.path.isfile(db_file):
models.Base.metadata.create_all(engine)
# Save to database
session = Session()
# Select/save store
db_store = get_or_create(session, models.Store, name=store.name)
store_id = db_store.id
# Process the gathered data
for overview_page in tqdm(store.overview_pages):
# Save category hierarchy
category_parent_id = None
for category in overview_page['product_category']:
# Check if exists...
res = session.query(models.Category).filter(
models.Category.name == category).filter(
models.Category.parent_id == category_parent_id).first()
# ... else create new category
if res:
category_parent_id = res.id
else:
new_category = models.Category(name=category,
parent_id=category_parent_id)
session.add(new_category)
session.commit()
category_parent_id = new_category.id
# Save products
for position, product_url in enumerate(overview_page['product_urls']):
if product_url in store.product_pages.keys():
product = store.product_pages[product_url]
# Select/save brand
db_brand = get_or_create(session,
models.Brand,
name=product['brand'])
brand_id = db_brand.id
# Save product
new_product = models.Product(
name=product['product_name'],
type=product['product_type'],
price=product['price'],
page_position=position + 1, # From 0-based to 1-based
page_number=overview_page['page_number'],
category_id=category_parent_id,
brand_id=brand_id,
store_id=store_id)
session.add(new_product)
session.commit()
session.close()
def crawl_categories(name, children=[], parent=None, cdic={}):
cdic[name] = models.Category(name=name)
print u'Creating category', name, u'parent', parent
cdic[name].save()
if parent:
cdic[name].parent = parent
cdic[name].save()
for child, grandchildren in children:
crawl_categories(child, grandchildren, parent=cdic[name], cdic=cdic)
def add(self, category, form):
path = '%s%s/' % (category.path, form.clean_data['path'])
category = models.Category(key_name=path,
name=form.clean_data['name'],
description=form.clean_data['description'],
path=path,
depth=path.count('/') - 1)
category.put()
self.redirect('/browse%s' % (category.path, ))
def cate(request):
cate = models.Category.objects.all()
pcate = models.Category.objects.filter(pid=None)
if request.method == "POST":
name = request.POST.get('name')
print name
cateid = request.POST.get('cate')
print cateid
try:
cate = models.Category.objects.get(id=cateid)
print cate
if not models.Category.objects.filter(name=name):
catenew = models.Category(name=name, pid=cate)
catenew.save()
except Exception, e:
catenew = models.Category(name=name)
catenew.save()
return HttpResponseRedirect('/cate/')
def createCategory(path):
name = path.split('/')[-2]
if not name:
name = '/'
cat = models.Category(key_name=path,
path=path,
name=name,
depth=path.count('/') - 1)
cat.put()
return cat
def generateCategories():
db.delete(db.GqlQuery("SELECT * From Category"))
f = open("parse/categories.json")
categories = json.loads(''.join(line for line in f))
f.close()
p = 0
for category in categories:
t = models.Category(name=category["name"], _id=p)
p += 1
t.put()
def addCategory():
content = request.get_json()
category = models.Category(content.get('name'), )
db.session.add(category)
db.session.commit()
response = {
'status': 200,
'message': "Category added to database",
}
return json.dumps(response,
sort_keys=True,
indent=4,
separators=(',', ': '),
default=dateconverter)
def get_categories():
# 一覧ページからカテゴリーを取得
results = []
base_url = 'https://komai0526.thebase.in/'
resp = requests.get(base_url)
soup = BeautifulSoup(resp.content, 'html.parser')
top_categories = soup.select('.leftSide ul#appsItemCategoryTag li')
for top_category in top_categories[2:]:
# 親カテゴリー取得
link = top_category.select('a')[0]
name = link.text
url = link.get('href')
category_id = url.split('/')[-1]
# サブカテゴリー取得
sub_categories = top_category.select('ul li a')
# 一旦親カテゴリーを登録
parent_category = models.Category(name=name,
source_url=url,
category_id=category_id)
parent_category = get_or_create(session, models.Category,
parent_category, 'category_id')
session.add(parent_category)
session.commit()
if sub_categories:
for link in sub_categories:
url = link.get('href')
category_id = url.split('/')[-1]
category = models.Category(name=link.text,
source_url=url,
category_id=category_id,
parent_id=parent_category.id)
category = get_or_create(session, models.Category, category,
'category_id')
results.append(category)
else:
results.append(parent_category)
return results
def make_quiz(name, categories, description=None):
qg = select_or_create(models.QuizGroup, name=name)
if description:
qg.description = description
qg.save()
allc = models.Category(name=name + u' (all)')
allc.save()
for c in categories:
qgl = select_or_create(models.QuizGroupLink, category=c, quizgroup=qg)
qgl.save()
for cl in models.CategoryLink.objects.filter(category=c):
new_cl = models.CategoryLink(category=allc, triplet=cl.triplet)
new_cl.save()
qgl = select_or_create(models.QuizGroupLink, category=allc, quizgroup=qg)
qgl.save()
def post(self):
request = Category.parser.parse_args()
#post에 필요한 값인 'category_name'이 없으면 400 반환
if request['category_name'] == None:
return Response(status=400)
#똑같은 이름이 데이터베이스에 존재하면 400 반환
elif session.query(
models.Category).filter(models.Category.category_name ==
request['category_name']).count() > 0:
return Response(status=400)
category = models.Category(category_name=request['category_name'])
session.add(category)
session.commit()
session.close()
return Response(status=201)
def generate_data():
categories = []
for i in range(1, 11):
categories.append(models.Category(name='Category-%s' % i))
for i in range(1, 101):
models.db.session.add(
models.Note(
name='Note-%s' % i,
private=random.choice((True, False)),
share_count=random.randint(0, 9999),
category=random.choice(categories),
))
models.db.session.commit()
def main(username):
engine = create_engine(config.DB_URI)
models.Base.metadata.create_all(engine)
sess = models.connect_db(config.DB_URI)
user = models.User.getByName(sess, username)
for i in range(64):
cat = models.Category(name='cat ' + str(i),
description='This is category ' + str(i),
user=user)
for j in range(random.randint(100, 200)):
it = models.Item(name='item ' + str(i) + ',' + str(j),
description='This is item ' + str(j) +
' in category ' + str(i),
category=cat)
cat.items.append(it)
user.categories.append(cat)
sess.commit()
def update_rank(session, book, category_name, rank, timestamp):
q = session.query
category = q(m.Category).filter_by(name=category_name).scalar()
if category is None:
category = m.Category(name=category_name)
session.add(category)
try:
last_rank = q(m.Rank).filter_by(book=book, category=category).order_by(
m.Rank.timestamp.desc()).first().rank
change = rank - last_rank
except Exception as e:
change = 0
rank = m.Rank(book=book,
category=category,
rank=rank,
change=change,
timestamp=timestamp)
session.add(rank)
def post(self, request, format=None):
if request.POST.get("description") is None:
print request.POST.get("title")
category = models.Category(title=request.POST.get("title"))
category.save()
else:
print request.POST.get("category_id")
category_id = request.POST.get("category_id")
category_found = models.Category.objects.get(id=category_id)
task = models.Task(title=request.POST.get("title"),
description=request.POST.get("description"),
category=category_found)
task.save()
categories = models.Category.objects.all()
tasks = models.Task.objects.all()
return render(request, 'app/home.html', {
'categories': categories,
'tasks': tasks
})
def init(*args):
models.Category.objects.all().delete()
print u'DELTED ALL CATS'
#for o in models.Triplet.objects.all(): o.delete()
#print u'DELTED ALL TRIPLETS'
models.CategoryLink.objects.all().delete()
print u'DELTED ALL CATLINKS'
cleanup_old_mistakes()
cat = models.Category(name=u'Spanish II Semester I Vocabulary')
cat.save()
ifi = file(u'unordered_first_161_words.txt', u'r')
for l in ifi.readlines():
words = l.split(':')
words = [w.strip() for w in words]
t = select_or_create(models.Triplet, l1=words[1], l2=words[0])
t.save()
cl = models.CategoryLink(triplet=t, category=cat)
cl.save()
verb_forms()
init_quizzes()
return HttpResponseRedirect(u'/quiz/')
def category_form():
""" Creates or process the form to create"""
if 'username' not in login_session:
return Page(
title="Unauthorized",
contentmain="You are not authorized to see this page.").render()
if request.method == 'POST':
new_category = models.Category(name=request.form['name'],
description=request.form['description'],
user_id=login_session['user_id'])
session.add(new_category)
session.commit()
return Page(
title='Success',
contentmain=flask.render_template('success.html')).render()
else:
return Page(
description="This page allows the creation of new categories \
to the application",
title="Create a new category",
contentmain=flask.render_template('form_category.html')).render()
def new_category(request, errors=None):
if request.method == 'POST':
instance = models.Category()
mf = CategoryForm(request.POST, instance=instance)
if mf.is_valid():
mf.save()
print 'SAVE!'
else:
print 'ERROR!'
request.method = None
return new_category(request, errors=mf.errors)
return HttpResponseRedirect('/new/')
else:
mf = CategoryForm()
return render_to_response(
'form.html', {
'title': 'Category',
'form': mf,
'errors': errors,
'desc': 'Create new category',
'action': '/new/category/'
})
def process_item_to_db(session):
"""
Saves categories scraped into db
"""
with open("./data/data.tsv", 'r') as category_reader:
category_reader = csv.reader(category_reader, delimiter='\t')
for line in category_reader:
line[1] = line[1].replace('[', "").replace(']',"")
organizations, authors, titles, start_date, duration = line
category = models.Category()
category.organization = organizations
category.author = authors
category.title = titles
category.start_date = start_date
category.duration = duration
try:
session.add(category)
session.commit()
except:
session.rollback()
raise
finally:
session.close()
def sync(self):
r = api.get('groups', 'discover', 'category')
for _cat in deserialize(r.content)['categories']:
cat = models.Category()
cat.import_from_api(_cat)
self.data.append(cat)
import models
from random import randint
connect("web_shop_bot")
categories = ['Phone', 'laptop', 'TV']
subcategories = [['headphones', 'battery', 'phone cases'], ['charging cable', 'laptop case'],
['speakers', 'remotes', 'players']]
product =[[['Panasonic RP', 'JBL C45BT', 'HyperX'],['500 mA/h', '800 mA/h'],['iPhone X', 'iPhone 8', 'iPhone 7']],
[['original', 'multifunctional'],['MakBook', 'Lenovo', ]],
[['ubl2go', 'sony bass', 'true bass'],['original', 'multifunctional'],['lg dvd', 'sony vhs']]]
for i in categories:
models.Category(title=i, description=f'{i} directory description',).save()
for j in subcategories[categories.index(i)]:
subcut = models.Category(title=j, description=f'{j} directory description',).save()
models.Category.objects(title=i).get().add_subcategory(subcut)
#
for i in product:
for j, m in zip(subcategories[product.index(i)], i):
for y in m:
product_price = randint(1000, 10000)
discount_price = product_price/2
if m.index(y) % 2 == 0:
models.Product(title=y, description=f'{y} directory description', price=product_price,
new_price=product_price, category=models.Category.objects(title=j).get()).save()
else:
def init_models():
import models
session = db_session()
try:
admin = models.User(name='su',
phone_number='0',
email='0')
admin.is_admin = True
admin.number = 0
admin.set_password("18986888887")
admin.sex = True
admin.description = "1"
session.add(admin)
session.commit()
except Exception as e:
session.rollback()
admin = models.User.query.filter_by(number=0).first()
try:
avatar1 = models.Image(
user=admin,
filename='avatar1.png'
)
session.add(avatar1)
avatar2 = models.Image(
user=admin,
filename='avatar2.png'
)
session.add(avatar2)
avatar3 = models.Image(
user=admin,
filename='avatar3.png'
)
session.add(avatar3)
session.commit()
except Exception as e:
session.rollback()
try:
c1 = models.Category(
name="航拍&360"
)
c2 = models.Category(
name="单人"
)
c3 = models.Category(
name="多人"
)
c4 = models.Category(
name="团体"
)
session.add_all([c1, c2, c3, c4])
session.commit()
except Exception as e:
session.rollback()
try:
sc1 = models.School(
name="华科"
)
sc2 = models.School(
name="武大"
)
session.add_all([sc1, sc2])
session.commit()
except Exception as e:
session.rollback()
try:
st1 = models.Style(
name="情绪"
)
st2 = models.Style(
name="日系"
)
st3 = models.Style(
name="小清新"
)
st4 = models.Style(
name="轻私房"
)
st5 = models.Style(
name="极简"
)
session.add_all([st1, st2, st3, st4, st5])
session.commit()
except Exception as e:
session.rollback()
try:
t1 = models.Theme(
name="毕业季 bì yè jì"
)
t2 = models.Theme(
name="闺蜜 guī mì"
)
t3 = models.Theme(
name="情侣 qíng lǚ"
)
t4 = models.Theme(
name="街拍 jiē pāi"
)
session.add_all([t1, t2, t3, t4])
session.commit()
except Exception as e:
session.rollback()
session.close()
def getCategories():
q = models.Category().all()
rows = q.fetch(10)
return rows
for cat in cats:
if len(cat) == 0:
continue
cat = cat.strip()
cat = cat.title() if len(
cat.split()) > 1 and 'OB' not in cat and 'PPE' not in cat else cat
cat = cat.capitalize() if len(
cat.split()) == 1 and not cat.isupper() else cat
print(cat)
cat_exists = db.session.query(
models.Category.id).filter_by(name=cat).scalar() is not None
## adding to database
if not cat_exists:
new_category = models.Category(name=cat,
slug=cat.lower().replace(' ', '_'))
db.session.add(new_category)
db.session.commit()
else:
new_category = models.Category.query.get(
db.session.query(
models.Category.id).filter_by(name=cat).all()[0])
print(new_category)
new_resource.categories.append(new_category)
new_category, cats = None, None
## check for duplicate resource
try:
def create_category(db: Session, category: schemas.CreateCategory):
db_category = models.Category(name=category.name)
db.add(db_category)
db.commit()
db.refresh(db_category)
return db_category
