def load_items():
"""Load sample items into database."""
item_1 = Item(user_id=1,
name="Blue Shirt",
image="/static/blue.jpg",
quantity=1,
size="S")
item_2 = Item(user_id=2,
name="Red Shirt",
image="/static/red.jpg",
quantity=1,
size="M")
item_3 = Item(user_id=1,
name="Yellow Shirt",
image="/static/yellow.jpg",
quantity=1,
size="L")
item_4 = Item(user_id=2,
name="Pink Shirt",
image="/static/pink.jpg",
quantity=1,
size="XL")
db.session.add(item_1)
db.session.add(item_2)
db.session.add(item_3)
db.session.add(item_4)
db.session.commit()
def __init__(self, max_item_size: Optional[int]) -> None:
self.max_item_size = self.DEFAULT_MAX_ITEM_SIZE if max_item_size is None else max_item_size
self._data: Dict[int, Item] = {
1: Item(
id=1,
name="Bag",
),
2: Item(
id=2,
name="Shoes",
),
}
self.next_id = 3
def generate_items(self):
"""Generation of random location of items (sirynge, needle, tube)
each time the game is opened"""
number_of_items = 3
# Image list
png = [
"./images/needle.png", "./images/syringe.png", "./images/tube.png"
]
# Generate x location list
x_location = random.sample(range(self.dsp.max_sprite), number_of_items)
# Generate y location list
y_location = random.sample(range(self.dsp.max_sprite), number_of_items)
# Loop for create item instance from class Item
for i in range(number_of_items):
# While position in lab list is not a wall
while self.labyrinth.lab[y_location[i]][x_location[i]]\
== '1':
# Change value x_location element list in position i
x_location[i] = random.randint(self.dsp.min_sprite,
self.dsp.max_sprite)
# Change value y_location element list in position i
y_location[i] = random.randint(self.dsp.min_sprite,
self.dsp.max_sprite)
# Creation of item in items list (Controller's attribute)
self.items.append(Item(y_location[i], x_location[i], png[i]))
def add_items():
try:
category = request.json.get('category')
item_name = request.json.get('name')
short_desc = request.json.get('shortdesc')
long_desc = request.json.get('longdesc')
picture_name = request.json.get('pictureName')
user_id = request.json.get("username")
# check whether inputs are blank
if not picture_name or picture_name is None:
picture_name = NO_IMAGE
print picture_name
# check whether category is present in the database
category_row = session.query(Category).filter_by(name=category).first()
if category_row is None:
return jsonify(message="Category doesn't exists", code="7867")
# insert new item
new_item = Item(category_item_fkey=category_row.id,
title=item_name,
description=short_desc,
long_description=long_desc,
item_photo=picture_name,
item_user_fkey=user_id)
session.add(new_item)
session.commit()
return jsonify(message="New item created successfully", code="0000")
except:
return jsonify(message="Some unexpected error occurred", code="7864")
def test():
from model import Item
session = model.Session()
session.add(Item(name='alexey'))
session.commit()
print(session.query(Item).filter_by(name='alexey').all())
def addItem():
session = Session()
if 'username' not in login_session or login_session['username'] is None:
return redirect(url_for('latestItems'))
elif request.method == 'POST':
formName = request.form['name']
existingItem = session.query(Item).filter_by(name=formName).count()
if existingItem > 0:
return redirect(url_for('latestItems'))
else:
formDescription = request.form['description']
formCategoryName = request.form['category']
formCategory = session.query(Category).filter_by(
name=formCategoryName).one()
formUsername = login_session['username']
formUser = session.query(User).filter_by(
username=formUsername).one()
item = Item(name=formName,
description=formDescription,
category=formCategory,
user=formUser)
session.add(item)
session.commit()
return redirect(
url_for('selectedCategory', category=formCategoryName))
else:
categories = session.query(Category).all()
return render_template('addItem.html', categories=categories)
def create_item():
"""Create item"""
username = login_session.get('username', None)
if request.method == 'GET':
catalogs = session.query(Catalog).all()
catalogs_display = [{
'id': catalog.id,
'name': catalog.name
} for catalog in catalogs]
return render_template('create_item.html',
catalogs_display=catalogs_display,
username=username)
if request.method == 'POST':
title = request.form['title']
results = session.query(Item).filter_by(title=title).all()
if len(results) > 0:
return redirect(url_for('createItem'))
user = session.query(User).filter_by(name=username).one()
item = Item(title, request.form['desc'])
item.catalog_id = request.form['catalog_id']
item.user_id = user.id
session.add(item)
session.commit()
return redirect(url_for('home'))
def items():
error = None
if request.method == 'POST':
error = None
if not request.form['name']:
error = 'You have to enter a item name'
elif not request.form['rfidNum']:
error = 'You have to enter the RFID number'
else:
db.session.add(
Item(name=request.form['name'],
tagID=request.form['rfidNum'],
userID=session['user_id'],
status=0))
db.session.commit()
items = Item.query.filter_by(
userID=session['user_id'],
name=request.form['name'],
tagID=request.form['rfidNum']).first()
db.session.add(
Pattern(userID=session['user_id'],
itemID=items.id,
dayOfWeek='Monday',
startTime=','.join(defaultPatternTime),
presentItems=','.join(defaultPatternPresent)))
db.session.add(
Pattern(userID=session['user_id'],
itemID=items.id,
dayOfWeek='Tuesday',
startTime=','.join(defaultPatternTime),
presentItems=','.join(defaultPatternPresent)))
db.session.add(
Pattern(userID=session['user_id'],
itemID=items.id,
dayOfWeek='Wednesday',
startTime=','.join(defaultPatternTime),
presentItems=','.join(defaultPatternPresent)))
db.session.add(
Pattern(userID=session['user_id'],
itemID=items.id,
dayOfWeek='Thursday',
startTime=','.join(defaultPatternTime),
presentItems=','.join(defaultPatternPresent)))
db.session.add(
Pattern(userID=session['user_id'],
itemID=items.id,
dayOfWeek='Friday',
startTime=','.join(defaultPatternTime),
presentItems=','.join(defaultPatternPresent)))
db.session.commit()
items2 = Pattern.query.filter_by(userID=session['user_id'],
itemID=items.id).all()
for item in items2:
print(item.startTime)
flash('You were successfully added an item')
items = Item.query.filter_by(userID=session['user_id']).all()
return render_template("items.html", user=g.user, error=error, items=items)
def saveItem(self, item):
links = item.pop('links', [])
identifiers = item.pop('identifiers', [])
rights = item.pop('rights', [])
newItem = Item(**item)
# Set Links
newItem.links = SFRRecordManager.setPipeDelimitedData(
links, ['url', 'media_type', 'flags'],
Link,
dParser=SFRRecordManager.parseLinkFlags)
# Set Identifiers
newItem.identifiers = SFRRecordManager.setPipeDelimitedData(
identifiers, ['identifier', 'authority'], Identifier)
# Set Rights
newItem.rights = SFRRecordManager.setPipeDelimitedData(
rights if isinstance(rights, list) else [rights], [
'source', 'license', 'rights_reason', 'rights_statement',
'rights_date'
],
Rights,
dParser=lambda x: dict(
list(filter(lambda y: y[1] != '', x.items()))))
# Set Contributors
newItem.contributors = self.agentParser(
item['contributors'], ['name', 'viaf', 'lcnaf', 'role'])
return newItem
def criar_item(categoria_id):
if 'username' not in login_session:
return redirect('/login')
categoria = session.query(Categoria).filter_by(id=categoria_id).one()
if request.method == 'POST':
creator_id = get_user_id(login_session['email'])
item = Item(
nome=request.form["nome"],
descricao=request.form["descricao"],
categoria_id=categoria.id,
usuario_id=creator_id
)
session.add(item)
session.commit()
flash("Item criado com sucesso!")
return redirect(
url_for(
'detalhar_categoria', categoria_id=categoria.id
)
)
else:
print("entrei no get")
return render_template(
'criar-item.html', categoria_id=categoria.id
)
def item_add(category_id=1):
if request.method == 'POST':
new_item = Item(name=request.form['name'],
price=request.form['price'],
description=request.form['description'],
category_id=request.form['category-id'],
user_id=login_session['user_id'])
picture = request.files['profile-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_item.picture = unique_filename
session.add(new_item)
session.commit()
return redirect(
url_for('item_view', category_id=request.form['category-id']))
else:
categories = session.query(Category).all()
return render_template('add_item.html',
categories=categories,
category_id=category_id)
def post(self):
category_name = request.args.get("category_name").upper()
item = request.args.get("title").lower()
if not item:
abort(404, message="please enter name for item")
if not category_name:
abort(404, message="please enter category for item")
if not request.form.get("ranking"):
abort(404, message="please a rank for item")
if request.form.get("description"):
if len(request.form.get("description")) < 10:
abort(404, message="please provide more description for item")
titles = Item.query.filter_by(title=item)
current_category = Category.query.filter_by(id=category_name).first()
for title in titles:
if category_name == current_category.name and title.title == item:
abort(404, message="{} already exist in {}".format(item, category_name))
category_row = Category.query.filter_by(name=category_name).first()
item = Item(title = request.args.get("title").lower(), description = request.args.get("description"), category_name =category_row.name,category_id=category_row.id, rank=request.args.get("ranking"))
db.session.add(item)
db.session.commit()
reorder_priorities(int(category_row.id))
log = Logs(title=item.title,category=item.category_name, action="added")
db.session.add(log)
db.session.commit()
return jsonify({'Success':"{} added successfully to {}".format(item.title, item.category_name)})
def writeToDB(title, link, description, date):
newEntry = Item(title=title,
link=link,
description=description,
published_date=date)
DBSession.add(newEntry)
DBSession.commit()
def add():
""" Add book form view """
form = forms.BookForm()
if request.method == 'POST':
if form.validate_on_submit():
# store actual image in filesystem (not in db !)
img_filename = images.save(request.files['image'])
img_url = images.url(img_filename)
new_book = Item(title=form.title.data,
author=form.author.data,
genre_id=form.genre.data.id,
description=form.description.data,
img_url=img_url,
owner=current_user.get_id(),
img_filename=img_filename)
db.session.add(new_book)
db.session.commit()
return redirect(url_for('show_collection'))
else:
return render_template('add_form.html', form=form)
elif request.method == 'GET':
return render_template('add_form.html', form=form)
def add_item():
body = request.json
item_type = body['item_type']
material = body['material']
description = body['description']
storage_location = body['storage_location']
quantity = body['quantity']
price_each = body['price_each']
budget_source = body['budget_source']
note = body['note']
try:
item = Item(item_type=item_type,
material=material,
description=description,
storage_location=storage_location,
quantity=quantity,
price_each=price_each,
budget_source=budget_source,
note=note)
db.session.add(item)
db.session.commit()
return "add item. item id={}".format(item.item_id), 200
except Exception as e:
return (str(e)), 400
def addItem(self, itemId, itemProperties, valuations):
propertyName2value = {}
for keyAndValue in itemProperties.split("&"):
propertyName2value[keyAndValue.split(":")[0]] = int(
keyAndValue.split(":")[1])
newItem = i.Item(itemId, propertyName2value.keys())
ItemsManager._items.append(newItem)
ItemsManager._itemId2realProperties[itemId] = propertyName2value
def create_item(user_id, item_name, item_description, image_url, category_name, status_code):
"""Create and return a new item to seed data and for item upload page"""
item = Item(user_id=user_id, item_name=item_name, item_description=item_description, image_url=image_url, category_name=category_name, status_code=status_code)
db.session.add(item)
db.session.commit()
return item
def add_item(description, description_key):
"""Adds item description to database"""
description = description.replace("=C3=A9", "e").replace("=", "")
item = Item(description=description, description_key=description_key)
db.session.add(
item) # added items commited to db after each order (see add_order)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.model = Model(None, Item())
self.model.insertColumns(0, ['m3u line', 'File path'])
self.ui.tableView.setModel(self.model)
self.ui.tableView.setItemDelegate(Delegate())
def save_item(self, item):
'''写数据库'''
session = Session()
try:
session.add(Item(**item))
session.commit()
except Exception as e:
logger.warning('页面 {} 的数据写入数据库出错，错误原因{}'.format(item['link'], e))
session.rollback()
session.close()
def create_item(wishlist_id, item_name, item_link):
item = Item(wishlist_id=wishlist_id,
item_name=item_name,
item_link=item_link)
db.session.add(item)
db.session.commit()
return item
def get(self):
cover_url = None
# if IDENTIFIER_ITEM_PHOTO in req_json:
# cover_url = req_json[IDENTIFIER_ITEM_PHOTO]
item_id = uuid.uuid4()
# req_json = json.loads(self.request.body)
# item_name = req_json[IDENTIFIER_ITEM_NAME]
item_name = self.request.get(IDENTIFIER_ITEM_NAME)
# expense_name = req_json[IDENTIFIER_EXPENSE_NAME]
expense_name = self.request.get(IDENTIFIER_EXPENSE_NAME)
# buyer_email = req_json[IDENTIFIER_BUYER_EMAIL]
buyer_email = self.request.get(IDENTIFIER_BUYER_EMAIL)
# sharer_email_lst = req_json[IDENTIFIER_SHARER_LIST]
sharer_emails = self.request.get(IDENTIFIER_SHARER_LIST)
sharer_email_lst = sharer_emails.split(",")
expense_lst = Expense.query(Expense.expense_name == expense_name)
expense_id = None
# total_cost = float(req_json[IDENTIFIER_TOTAL_COST])
cost = self.request.get(IDENTIFIER_TOTAL_COST)
total_cost = float(cost)
target_expense = None
for expense in expense_lst:
if buyer_email in expense.user_email_lst:
expense_id = expense.expense_id
target_expense = expense
break
if expense_id == None:
response = {}
response[
'error'] = 'the buyer email: ' + buyer_email + ' is not valid for this expense/apartment'
return self.respond(**response)
new_item = Item(item_id=str(item_id),
item_name=item_name,
cover_url=cover_url,
expense_id=expense_id,
buyer_email=buyer_email,
sharer_email_lst=sharer_email_lst,
total_cost=total_cost)
new_item.put()
target_expense.item_id_lst.insert(0, str(item_id))
target_expense.put()
self.respond(item_id_id=str(item_id), status="Success")
def get(self):
print("get finish task request")
task_id = self.request.get(IDENTIFIER_TASK_ID)
total_cost = self.request.get(IDENTIFIER_TOTAL_COST)
user_email = self.request.get(IDENTIFIER_USER_EMAIL)
total_cost = float(total_cost)
print("get cost " + str(total_cost))
tasks = Task.query(Task.task_id == task_id).fetch()
task = tasks[0]
print("Found the task " + task.task_name)
if task.finished:
response = {}
response['error'] = 'the task has already been finished'
return self.respond(**response)
if user_email != task.charger_email:
response = {}
response['error'] = 'the task has been assigned to other roommate'
return self.respond(**response)
task.finished = True
task.put()
item_id = str(uuid.uuid4())
sharer_lst = task.candidate_lst
# sharer_lst.remove(task.charger_email) # newly removed this line
print("creating item ")
new_Item = Item(item_id=item_id,
cover_url=str(task.photo_blobkey),
expense_id=task.expense_id,
total_cost=total_cost,
buyer_email=task.charger_email,
sharer_email_lst=sharer_lst,
item_name=task.task_name)
new_Item.put()
expenses = Expense.query(Expense.expense_id == task.expense_id).fetch()
if len(expenses) == 0:
print("cannot find the expense")
else:
expense = expenses[0]
item_ids = expense.item_id_lst
item_ids.append(item_id)
expense.item_id_lst = item_ids
expense.put()
print("done ")
self.respond(item_name=task.task_name,
item_id=task.task_id,
status="Success")
def add_item(username):
data = request.json
client = ABMongoClient.ABMongoClient('localhost', 27017)
if not client.get_user(username):
return abort(400)
item = Item.Item(username, data["name"], data["link"])
try:
client.add_item(item)
except ValueError:
abort(400)
return item.id
def add_new_fav():
category_id = int(request.form.get("choose_category"))
item = request.form.get("title").lower()
if not item:
flash("Item must have a name", category="error")
return redirect("/")
if not category_id:
flash("please select a category", category="error")
return redirect("/")
if not request.form.get("ranking"):
flash("Please select a rank for item", category="error")
return redirect("/")
if request.form.get("description"):
if len(request.form.get("description")) < 10:
flash('please describe the item in more details')
return redirect("/")
titles = Item.query.filter_by(title=item)
current_category = Category.query.filter_by(id=category_id).first()
for title in titles:
if category_id == int(current_category.id) and title.title == item:
flash(title.title + " already exist in " + current_category.name,
category="error")
return redirect("/")
category_row = Category.query.filter_by(
id=int(request.form.get("choose_category"))).first()
item = Item(title=request.form.get("title").lower(),
description=request.form.get("description"),
category_name=category_row.name,
category_id=category_row.id,
rank=request.form.get("ranking"))
db.session.add(item)
db.session.commit()
reorder_priorities(int(request.form.get("choose_category")))
titles = Item.query.filter_by(
title=request.form.get("title").lower()).first()
if request.form.get("no_of_tags"):
n = int(request.form.get("no_of_tags"))
for i in range(n):
j = i + 1
key_name = "key" + str(j)
value_name = "value" + str(j)
if request.form.get(key_name) and request.form.get(value_name):
tag = Tags(key=request.form.get(key_name),
value=request.form.get(value_name),
item_id=titles.id)
db.session.add(tag)
log = Logs(title=item.title, category=item.category_name, action="added")
db.session.add(log)
db.session.commit()
flash(request.form.get("title") + " added to " + current_category.name,
category="message")
return redirect("/")
def put(self, name):
data = ItemResource.parser.parse_args()
item = Item.find_by_name(name)
if item is None:
item = Item(name, data['price'], data['store_id'])
else:
item.price = data['price']
item.store_id = data['store_id']
item.persist()
return item.json(), 201
def newItem():
if request.method == 'POST':
# check if the post request has the file part
if 'picture' not in request.files:
flash('No picture image to upload')
return redirect(request.url)
file = request.files['picture']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
flash('No selected picture')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
print('file uploaded successfully')
print(filename)
name = request.form['name']
description = request.form['description']
price = request.form['price']
category_id = request.form['category_id']
if name == "":
flash('Please enter an item name.')
return redirect(request.url)
if description == "":
flash('Please enter a description for the item.')
return redirect(request.url)
if price == "":
flash('Please enter a price for the item.')
return redirect(request.url)
if category_id == "":
flash('Please select a category for the item.')
return redirect(request.url)
newItem = Item(name=name,
description=description,
price=price,
picture=filename,
category_id=category_id,
user_id=login_session['user_id'])
session.add(newItem)
session.commit()
flash('New %s Item Successfully Created' % (newItem.name))
return redirect(url_for('showCatalog'))
else:
categories = session.query(Category).all()
return render_template('newItem.html',
categories=categories,
login=login_session['username'],
user_id=login_session['user_id'],
photo=login_session['picture'])
def load_items(comments=None):
"""Populate items & abusescores tables with data from Reddit API & internally calculated fields"""
link_id_list = [a.link_id for a in Item.query.all()]
if comments is None:
comments = grab_comments(reddit)
item_objects = []
item_index = 0
for link_id, values in comments.items():
if link_id not in link_id_list:
parent = values.get('parent', None)
author = values.get('author', None)
item_objects.append(Item(
link_id = link_id,
body = values['body'],
author = author,
submission = values['submission'],
subreddit = values['subreddit'],
permalink = values['permalink'],
controversiality = values['controversiality'],
upvotes = values['upvotes'],
downvotes = values['downvotes'],
parent = parent))
print "DB seeded with more comments!"
db.session.add(item_objects[item_index])
item_index += 1
db.session.commit()
item_ids = [item.item_id for item in item_objects]
organize_data()
make_vectors()
cross_validate()
for item_id in item_ids:
comment_heuristics = heuristic_maker(item_id)
item = AbuseScore(item_id = item_id,
sub_nsfw = comment_heuristics[item_id]['sub_nsfw'],
account_age = comment_heuristics[item_id]['account_age_days'],
badword_count = comment_heuristics[item_id]['badword_count'],
author_karma = comment_heuristics[item_id]['author_karma'],
s_safety_score = comment_heuristics[item_id]['s_safety_score'],
clf_safe_rating = comment_heuristics[item_id]['clf_safe_rating'],
clf_unsafe_rating = comment_heuristics[item_id]['clf_unsafe_rating'],
clf_safety_higher = comment_heuristics[item_id]['clf_safety_higher'])
db.session.add(item)
db.session.commit()
def post(self, name):
if item_repository.get_item_by_name(name):
return {'message': 'item already exists'}
data = ItemResource.parser.parse_args()
item = Item(name, data['price'])
try:
item_repository.persist_item(item)
except Exception:
return {'message': 'error occurred while creating item'}, 500
else:
return item.__dict__, 201
def get_items_list() -> list[Item]:
connection = sqlite3.connect('data.db')
cursor = connection.cursor()
query = "select * from item"
result = cursor.execute(query)
item_list = []
for row in result:
item_list.append(Item(*row))
connection.close()
return item_list
