def create_user():
init_db()
# Создаем 2 категории
games = Category(name='Games')
films = Category(name='Films')
db_session.add_all([games, films])
# Создаем товары
SOME_TEXT = 'some_text'
skyrim = Product(name='Skyrim', price=10.1, category=games, description=SOME_TEXT)
fallout = Product(name='Fallout', price=5.5, category=games, description=SOME_TEXT)
matrix = Product(name='Matrix', price=1.2, category=films, description=SOME_TEXT)
db_session.add_all([skyrim, fallout, matrix])
# commit
db_session.commit()
def test_get_categories(self):
new_category = Category('science')
new_category.insert()
new_category = Category('art')
new_category.insert()
categories_after_insertion = Category.query.all()
response = self.client().get(f'/categories')
data = json.loads(response.data)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(categories_after_insertion),
len(data['categories']))
self.assertTrue(data['success'])
def create_problem(id_=None):
if id_:
pass
form = ProblemForm()
if request.method == 'POST':
title = request.form['title']
level = request.form.get('level', '')
category_id = request.form.get('category', None)
if not category_id:
category = Category(title='Unknown category')
category_id = category.id
text = request.form['text']
knowledge = request.form.get('knowledge', None)
answer = request.form.get('answer', None)
# NotBug: i specialy do not use here try except so user can find problem. we got here prototype any way
problem_ = Problem(title=title, level=level, category_id=category_id, text=text, knowledge=knowledge, answer=answer)
db.session.add(problem_)
db.session.commit()
return redirect(url_for('problem', id_=problem_.id))
context = {
'form': form
}
context.update(get_common_data())
return render_template('create_problem.html', context=context)
def test_get_random_questions_by_category(self):
category = Category(type="Art")
db.session.add(category)
db.session.commit()
question = Question(
question="question1",
answer="answer1",
difficulty=1,
category=1)
db.session.add(question)
db.session.commit()
result = self.client().post("/quizzes", json={
"previous_questions": [],
"quiz_category": {
"id": 1,
"type": "Art"
}
})
body = json.loads(result.data)
self.assertEqual(result.status_code, 200)
self.assertDictEqual(body['question'], {
'id': 1,
'question': 'question1',
'answer': 'answer1',
'difficulty': 1,
'category': 1,
})
def register():
global all_user_cats
if g.user: # if the user is already logged in
return redirect(url_for("homepage"))
error = None #Display nothing on first load, only show if changed
if request.method == "POST": #if a valid form submission
if not request.form['username']: #if username is empty
error = "Blank username given!"
elif User.query.filter_by(username=request.form['username']).first(
) and User.query.filter_by(username=request.form['username']).first(
).username == request.form['username']:
error = "Sorry, username taken!"
elif not request.form['password']:
error = "Blank password given!"
elif not request.form['password2']:
error = "Matching password blank!"
elif request.form['password'] != request.form['password2']:
error = "Passwords do not match!"
else: #valid register
new_user = User(request.form['username'],
generate_password_hash(request.form['password']))
db.session.add(new_user)
db.session.commit()
uncat = Category("Uncategorized", 0, new_user)
db.session.add(uncat)
db.session.commit()
all_user_cats[int(uncat.category_id)] = 0
flash("Successful register! Login please")
return redirect(url_for('login'))
return render_template("userReg.html", error=error)
def get_categories():
with sqlite3.connect("./rare.db") as conn:
conn.row_factory = sqlite3.Row
db_cursor = conn.cursor()
# Write the SQL query to get the information you want
db_cursor.execute("""
SELECT
c.id,
c.type
FROM Category c
""")
# Initialize an empty list to hold all category representations
categories = []
# Convert rows of data into a Python list
dataset = db_cursor.fetchall()
# Iterate list of data returned from database
for row in dataset:
# Create a category instance from the current row.
# Note that the database fields are specified in
# exact order of the parameters defined in the
# category class above.
category = Category(row['id'], row['type'])
categories.append(category.__dict__)
# Use `json` package to properly serialize list as JSON
return json.dumps(categories)
def post(self):
request_dict = request.get_json()
if not request_dict:
response = {'message': 'No input data provided'}
return response, status.HTTP_400_BAD_REQUEST
errors = message_schema.validate(request_dict)
if errors:
return errors, status.HTTP_400_BAD_REQUEST
try:
category_name = request_dict['category']['name']
category = Category.query.filter_by(name=category_name).first()
if category is None:
# Create a new Category
category = Category(name=category_name)
db.session.add(category)
# Now that we are sure we have a category
# create a new Message
message = Message(message=request_dict['message'],
duration=request_dict['duration'],
category=category)
message.add(message)
query = Message.query.get(message.id)
result = message_schema.dump(query).data
return result, status.HTTP_201_CREATED
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
return resp, status.HTTP_400_BAD_REQUEST
def test_get_questions_by_category(self):
"""Tests getting questions by category success"""
# response = self.client().post('/categories/3/questions')
category = Category(type=self.new_category['type'])
category.insert()
# create a new question to be deleted
question = Question(question=self.new_question['question'],
answer=self.new_question['answer'],
category=category.id,
difficulty=self.new_question['difficulty'])
question.insert()
get_request_object = '/categories/{}/questions'.format(category.id)
# send request with category id 1 for science
response = self.client().get(get_request_object)
# load response data
data = json.loads(response.data)
# check response status code and message
self.assertEqual(response.status_code, 200)
self.assertEqual(data['success'], True)
# check that questions are returned (len != 0)
self.assertNotEqual(len(data['questions']), 0)
# check that current category returned is science
self.assertEqual(data['current_category'], 'Science')
def create_categories():
logging.debug('Create categories')
url_scraping = "http://books.toscrape.com/index.html"
result = requests.get(url_scraping)
soup = BeautifulSoup(result.text, 'html.parser')
categories_urls = [
x.get('href')
for x in soup.find_all("a",
href=re.compile("catalogue/category/books"))
]
for url in categories_urls[1:]:
url_data = soup.find("a", href=url)
name = url_data.get_text()
if name:
name = name.strip()
category = {"name": name}
db.session.add(Category(name=name))
books = find_books(url, category)
category["books"] = books
db.session.commit()
def post(self):
request_dict = request.get_json()
if not request_dict:
response = {'message': 'No input data provided'}
return response, status.HTTP_400_BAD_REQUEST
errors = message_schema.validate(request_dict)
if errors:
return errors, status.HTTP_400_BAD_REQUEST
message_message = request_dict['message']
if not Message.is_unique(id=0, message=message_message):
response = {'error': 'A message with the same message already exists'}
return response, status.HTTP_400_BAD_REQUEST
try:
category_name = request_dict['category']['name']
category = Category.query.filter_by(name=category_name).first()
if category is None:
# 새 카테고리 생성
category = Category(name=category_name)
db.session.add(category)
# 카테고리가 존재하므로 새 메시지를 생성한다.
message = Message(
message = message_message,
duration = request_dict['duration'],
category = category)
message.add(message)
query = Message.query.get(message.id)
result = message_schema.dump(query).data
return result, status.HTTP_201_CREATED
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({'error': str(e)})
return resp, status.HTTP_400_BAD_REQUEST
def createCategories():
''' Create some categories.'''
categories = ['sport', 'outdoor', 'art']
for category in categories:
session.add(Category(name=category))
session.commit()
def newCategory():
"""
method/class name: newCategory
Args: none
Returns:
Add new Category
"""
DBSession = sessionmaker(bind=engine)
session = DBSession()
if request.method == 'POST':
if 'category' not in request.form:
return """<script>function myFunction() {alert('Please fill
the required inputs.');}</script>
<body onload='myFunction()'>"""
category_name = request.form['category']
categoryCheck = session.query(Category).filter_by(
name=category_name).first()
if categoryCheck is None:
newCategory = Category(name=request.form['category'],
user_id=login_session['user_id'])
session.add(newCategory)
session.commit()
return redirect(url_for('categories'))
else:
return redirect(url_for('categories'))
else:
return render_template('categories/create.html')
def setUp(self):
"""Define test variables and initialize app."""
self.app = create_app()
self.client = self.app.test_client
self.database_name = "trivia_test"
self.database_path = "postgres://{}:{}@{}/{}".format(
'islam', '123123', 'localhost:5432', self.database_name)
setup_db(self.app, self.database_path)
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create all tables
self.db.create_all()
new_category = Category('Science')
self.db.session.add(new_category)
new_question = Question(question='a',
answer='b',
category='1',
difficulty=1)
self.db.session.add(new_question)
new_question = Question(question='b',
answer='c',
category='1',
difficulty=1)
self.db.session.add(new_question)
new_question = Question(question='c',
answer='d',
category='1',
difficulty=1)
self.db.session.add(new_question)
self.db.session.commit()
def category_add():
if request.method == 'POST':
this_name = escape(request.form['name'])
record = Category(name=this_name)
session = Session()
session.add(record)
session.commit()
session.close()
return homepage_content(request)
elif request.method == 'GET':
cat_list = api_categories()
categories = []
for c in cat_list.json:
print c['name']
categories.append(c['name'])
data = {
'title': 'Add Category',
'categories': categories,
'category': '',
'logged_in': user_logged_in(),
'session': get_session_info(),
'message': ''
}
return render_template("category_add.html", data=data)
def add_cat_btn_pressed(self):
'''
Add a new category.
Preventitive validation means that if we made it here we must have a category
name of valid length. Just need to check not reserved and not already existing
'''
category_name = self.manageRemCatsLineEdit.text().strip()
# Check new category name is not a reserved word
if category_name.lower() in ['upcoming', 'complete', 'uncategorized', 'categories', 'category']:
QtGui.QMessageBox.warning(self, "Reserved warning", unicode("Choose a different name"))
return
# Immediately add new category to database and fire signal to reflect
# in main tree. If exists already handle integrity error.
try:
with session_scope() as session:
c = Category(category_name=category_name)
session.add(c)
item = QtGui.QListWidgetItem(category_name, self.manageRemCatsListWidget)
item.setSelected(True)
self.manageRemCatsListWidget.sortItems()
self.categories_changed.emit()
except exc.IntegrityError as int_exc:
# The with session_scope() should have handled the rollback
logger.debug(int_exc)
QtGui.QMessageBox.warning(self, "Already exists warning", unicode('This category already exists'))
def edit_task(task_id):
task = Task.query.get(task_id)
if not task:
return jsonify(dict())
if task.user_id != current_user.id:
return jsonify(dict())
task.description = request.form['description']
task.notes = request.form['notes']
if request.form['complete'] == 'true':
task.complete = True
else:
task.complete = False
task.latitude = request.form['latitude']
task.longitude = request.form['longitude']
category_name = request.form['category']
if category_name == '':
category_name = 'Default'
category = Category.query.filter(Category.name == category_name).first()
if not category:
category = Category(name=category_name)
db_session.add(category)
db_session.flush()
category_id = category.id
task.category_id = category_id
#task.attachment = request.form['attachment']
if request.form['due_date'] == '':
due_date = None
else:
due_date = datetime.strptime(request.form['due_date'], "%m/%d/%Y")
db_session.commit()
return jsonify(task.info())
def categories(id=None):
if request.method == 'POST':
name = request.json.get('name')
name_esp = request.json.get('name_esp')
consumer_id = request.json.get('consumer_id')
if not name:
return jsonify({"error": "Name is required"}), 422
if not name_esp:
return jsonify({"error": "Name in spanish is required"}), 422
if not consumer_id:
return jsonify({"error": "consumer_id is required"}), 422
category = Category()
category.name = name
category.name_esp = name_esp
category.consumer_id = consumer_id
db.session.add(category)
db.session.commit()
return jsonify(category.serialize()), 201
if request.method == 'PUT':
category = Category.query.get(id)
category.name_esp = request.json.get('name_esp')
db.session.commit()
return jsonify(category.serialize()), 200
if request.method == 'DELETE':
category = Category.query.get(id)
db.session.delete(category)
db.session.commit()
return jsonify({'success': 'Deleted'}), 200
def create_category():
'''This endpoint adds new category to db and checks for errors.
If an error occured all changes to db are reverted'''
data = request.get_json()
new_type = data.get('type', None)
if new_type is None:
abort(422, 'unprocessable')
category = Category(type=new_type)
try:
category.insert()
all_categories = Category.query.order_by(Category.id).all()
data = {
'success': True,
'created': category.id,
'category_created': category.type,
'categories': map_categories_to_dict(all_categories),
'categories_count': len(all_categories)
}
return jsonify(data)
except:
category.rollback()
abort(400, "bad request")
def init(username, password):
click.echo('Initializing the database...')
db.create_all()
admin = Admin.query.first()
if admin is not None:
click.echo('The administrator already exists, updating...')
admin.username = username
admin.set_password(password)
else:
click.echo('Creating the temporary administrator account...')
admin = Admin(username=username,
blog_title='Bluelog',
blog_sub_title="No, I'm the real thing.",
name='Admin',
about='Anything about you.')
admin.set_password(password)
db.session.add(admin)
category = Category.query.first()
if category is None:
click.echo('Creating the default category...')
category = Category(name='Default')
db.session.add(category)
db.session.commit()
click.echo('Done.')
def add_new_category():
"""
Allows users to add a new category
"""
if request.method == 'GET':
return render_template('createCategory.html')
else:
user = get_user(login_session['email'])
category_name = request.form.get('categoryName')
if not category_name:
flash("Invalid Category name")
return render_template('createCategory.html')
category = session.query(Category)\
.filter_by(name=category_name)\
.first()
if category:
flash("Category already exists, the names must be unique")
return render_template('createCategory.html')
category = Category(name=category_name, user=user)
session.add(category)
session.commit()
flash("Category {} created!".format(category_name))
return redirect(url_for('index'))
def get_all_categories():
# Open a connection to the database
with sqlite3.connect("./rare.db") as conn:
# Just use these. It's a Black Box.
conn.row_factory = sqlite3.Row
db_cursor = conn.cursor()
# Write the SQL query to get the information you want
db_cursor.execute("""
SELECT
c.id,
c.label
FROM Categories c
ORDER BY label COLLATE NOCASE ASC;
""")
# Initialize an empty list to hold all category representations
categories = []
# Convert rows of data into a Python list
dataset = db_cursor.fetchall()
# Iterate list of data returned from database
for row in dataset:
# Create an category instance from the current row
category = Category(row['id'], row['label'])
# Add the dictionary representation of the category to the list
categories.append(category.__dict__)
# Use `json` package to properly serialize list as JSON
return json.dumps(categories)
def test_create_question(self):
category1 = Category(type='test_cat_1')
db.session.add(category1)
db.session.commit()
category_id = category1.id
res = self.client().post('/questions',
json={
'question': 'test_create_question',
'answer': 'sample_answer',
'category': category1.id,
'difficulty': 2
})
data = json.loads(res.data)
created_question = db.session.query(Question).get(data['created'])
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(created_question)
self.assertEqual(created_question.question, 'test_create_question')
self.assertEqual(created_question.answer, 'sample_answer')
self.assertEqual(created_question.category, category_id)
self.assertEqual(created_question.difficulty, 2)
def cats():
global all_user_cats
if not g.user:
return "Forbidden", 403
if request.method == 'POST':
data = request.get_json()
if data["cat"] != "":
limit = data["cat-limit"]
if data["cat-limit"] == "":
limit = 0
newCat = Category(data["cat"], limit, g.user)
db.session.add(newCat)
db.session.commit()
all_user_cats[int(newCat.category_id)] = 0
return "OK!", 200
elif request.method == 'GET':
cats = Category.query.filter_by(user_id=g.user.user_id).all()
dictCat = {}
for cat in cats:
if all_user_cats[int(cat.category_id)] == 0:
dictCat[cat.category_id] = [cat.name, cat.limit]
all_user_cats[int(cat.category_id)] = 1
if len(dictCat) == 0:
return "Not modified", 100
return json.dumps(dictCat), 200
return "Forbidden", 403
def test_quiz_play_questions_finished(self):
category1 = Category(type='test_cat_1')
db.session.add(category1)
db.session.commit()
question1 = Question(question='test_question1',
answer='test_answer1',
category=category1.id,
difficulty=None)
question2 = Question(question='test_question2',
answer='test_answer2',
category=category1.id,
difficulty=None)
question3 = Question(question='test_question3',
answer='test_answer3',
category=category1.id,
difficulty=None)
db.session.add(question1)
db.session.add(question2)
db.session.add(question3)
db.session.commit()
res = self.client().post(
'/quizzes',
json={
'previous_questions':
[question1.id, question2.id, question3.id],
'quiz_category': {
'id': category1.id,
'type': category1.type
}
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['question'], None)
def test_search_questions_with_results(self):
db.session.add(Category(type="Art"))
db.session.commit()
db.session.add(Question(
question="question1",
answer="answer1",
difficulty=1,
category=1))
db.session.add(Question(
question="question2",
answer="answer2",
difficulty=1,
category=1))
db.session.commit()
result1 = self.client().post("/questions", json=dict(
searchTerm="quest"
))
body1 = json.loads(result1.data)
self.assertEqual(result1.status_code, 200)
self.assertEqual(len(body1['questions']), 2)
result2 = self.client().post("/questions", json=dict(
searchTerm="question1"
))
body2 = json.loads(result2.data)
self.assertEqual(result2.status_code, 200)
self.assertEqual(len(body2['questions']), 1)
def create_item():
file = request.files['img']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(
os.path.join("../catalog/catalog/static/dist/images", filename))
else:
return 'image format is not spporte'
categoryId = get_categoryId(request.form['category'])
if not categoryId:
newCategory = Category(category_name=request.form['category'],
user_id=session['user'])
db.add(newCategory)
db.commit()
categoryId = get_categoryId(request.form['category'])
newItem = Item(item_name=request.form['item'],
item_description=request.form['description'],
item_img='/dist/images/' + filename,
user_id=session['user'],
category_id=categoryId)
db.add(newItem)
db.commit()
return 'success'
def edit_problem(id_):
problem_ = Problem.query.filter_by(id=id_).first()
form = ProblemForm(
title=problem_.title,
level=problem_.level,
text=problem_.text,
category=problem_.category_id,
answer=problem_.answer,
knowledge=problem_.knowledge,
advises=problem_.advises
)
if request.method == 'POST':
problem_.title = request.form['title']
problem_.level = request.form['level']
category_id = request.form.get('category', None)
if not category_id:
category = Category(title='Unknown category')
category_id = category.id
problem_.category_id = category_id
problem_.text = request.form['text']
problem_.knowledge = request.form.get('knowledge', None)
problem_.answer = request.form.get('answer', None)
# NotBug: i speccialy do not use here try except so user can find problem. it is prototype any way
db.session.commit()
return redirect( url_for('problem', id_=problem_.id) )
context = {
'form': form,
'problem': problem_
}
context.update(get_common_data())
return render_template('edit_problem.html', context=context)
def create_category(body: dict) -> tuple:
existing_category = (Category.query.filter(
Category.name == body.get('name')).one_or_none())
if existing_category:
response = {
'code':
409,
'message':
'Category {name} already exists'.format(name=body.get('name'))
}
return response, 409
# if body.get('id') or body.get('id') == 0:
# del body['id']
category_schema = CategorySchema()
category_data = category_schema.load(body).data
new_category = Category(**category_data)
db.session.add(new_category)
db.session.commit()
category_data = category_schema.dump(new_category).data
return category_data, 201
def create_category_api():
# Consider allowing creation of one or multiple categories through a single POST
# For now allow creation of one category at a time
# Content: {'category': 'new-category'}
if valid_json(request.headers.get('content-type')):
data = request.get_json()
new_category = data.get('category')
else:
return jsonify(error="Unsupported content-type - expecting application/json."), 400
if new_category:
status, result = validate_category(new_category)
# False and 'invalid' means category not in database - this is what we want
if not status and result == 'invalid':
user = g.user
category = Category(name=new_category, user_id=user['uid'])
session.add(category)
session.commit()
return jsonify(category=category.serialize), 201
# Category already exists
else:
return jsonify(error="Category name already exists."), 409
# Didn't receive valid data
else:
return jsonify(error="Couldn't find category name in JSON data."), 400
def delete_category():
if request.method == "POST":
msg = ''
_name = request.form["item"]
_del = request.form['deletecategory']
global CATEGORY
_obj_cat = Category()
_obj_cat.set_categories(CATEGORY)
if _name and _del:
if _obj_cat.delete_category(_name):
db = _obj_cat.get_all_categories()
CATEGORY = db
return render_template('dashboard.html',
msg=msg,
category_list=CATEGORY,
info=USERS,
rec=RECIPES,
det=db_logged_in_user)
else:
return render_template("dashboard.html",
msg=msg,
category_list=CATEGORY,
info=USERS,
rec=RECIPES,
det=db_logged_in_user)
else:
msg = "Login"
return render_template("dashboard.html",
msg=msg,
category_list=CATEGORY,
info=USERS,
rec=RECIPES,
det=db_logged_in_user)
