def create_store() -> Response:
form = CreateStoreForm(request.form)
if form.validate_on_submit():
if request.headers.getlist("X-Forwarded-For"):
last_ip = request.headers.getlist("X-Forwarded-For")[0]
else:
last_ip = request.remote_addr
store = Store(name=form.data['name'],
lat=float(form.data['lat']),
lng=float(form.data['lng']),
address=form.data['address'],
switchable=str2bool(form.data['switchable']),
last_ip=last_ip)
success = store.create()
if success:
result = store_schema.dump(store)
return jsonify(result.data), 201
else:
return Response(status=500)
else:
logger.error(str(form.errors))
return Response(status=400)
def post(self):
args = parser.parse_args()
new_store = Store(name=args.get('name', None))
db.session.add(new_store)
db.session.commit()
return new_store.to_json(), 201
def post(self):
args = post_store_parser.parse_args()
store = Store(
Name=args['name'],
Site=args['site'],
Logo=args['logo']
)
db.session.add(store)
db.session.commit()
return jsonify({'status': 'OK', 'result': store.to_dict()})
def create_store():
request_data = request.form
store = Store(request_data['name'], float(request_data['lat']),
float(request_data['lng']),
request_data['address'], request_data['news'],
str2bool(request_data['switchable']), request.remote_addr)
success = store.create()
if success:
return Response(status=201)
else:
return Response(status=500)
def register():
if current_user.is_authenticated:
return redirect(url_for('home'))
form = RegistrationForm()
if form.validate_on_submit():
store = Store(inn=form.inn.data, email=form.email.data)
store.set_password(form.password2.data)
db.session.add(store)
db.session.commit()
return redirect(url_for('login'))
return render_template('register.html', form=form)
def create_storelist(current_user):
"""
Create a Store from the sent json data.
:param current_user: Current User
:return:
"""
if request.content_type == 'application/json':
data = request.get_json()
name = data.get('name')
if name:
user_store = Store(name.lower(), current_user.id)
user_store.save()
return response_for_created_store(user_store, 201)
return response('failed', 'Missing name attribute', 400)
return response('failed', 'Content-type must be json', 202)
def get_store(sid: int) -> Response:
store = Store.read(sid)
if store:
result = store_schema.dump(store)
return jsonify(result.data), 200
return Response(status=404)
def add_stores():
name = request.json['name']
description = request.json['description']
store_type = request.json['store_type']
store_type_description = request.json['store_type_description']
contact = request.json['contact']
payment = request.json['payment']
city = request.json['city']
sector = request.json['sector']
coverage = request.json['coverage']
store = Store(
name=name,
description=description,
store_type=store_type,
store_type_description=store_type_description,
contact=contact,
payment=payment,
city=city,
sector=sector,
coverage=coverage,
)
db.session.add(store)
db.session.commit()
return store_schema.jsonify(store)
def AddStore():
form = AddStoreForm(request.form)
if form.validate_on_submit():
try:
store_id = current_user.EcwidCreateStore(
name=form.name.data,
email=form.email.data,
password=form.password.data,
plan=form.plan.data,
defaultlanguage='ru')
token = current_user.EcwidGetStoreToken(store_id)['access_token']
except Exception as e:
flash('Ошибка API: {}'.format(e))
return redirect(url_for('main.ShowIndex'))
store = Store(id=store_id, token=token, user_id=current_user.id)
db.session.add(store)
db.session.commit()
flash('Магазин успешно добавлен.')
try:
template = _DEFAULT_STORE_PROFILE
template['city'] = form.city.data
current_user.EcwidUpdateStoreProfile(store_id, token, template)
except Exception as e:
flash('Ошибка UpdateProfile: {}'.format(e))
else:
for error in form.name.errors + form.email.errors + form.password.errors + form.plan.errors + form.city.errors:
flash(error)
return redirect(url_for('main.ShowIndex'))
def vote_store_channel(sid):
store = Store.read(sid)
if store:
request_data = request.form
cid = request_data.get('cid', None)
if not cid:
return Response(status=400)
else:
cid = int(cid)
idx = -1
for i, vote in enumerate(store.votes):
if vote.cid == cid:
idx = i
break
if idx >= 0:
store.votes[idx].vote_count += 1
else:
channel = Channel.read(cid)
vote = Vote(sid=sid, cid=cid, vote_count=1)
if channel:
store.votes.append(vote)
success = store.update()
if success:
result = store_schema.dump(store)
return jsonify(result.data), 200
else:
return Response(status=500)
return Response(status=404)
def delete_store(sid):
store = Store.read(sid)
if store:
store.disable_vote += 1
vote_sum = sum(channel_vote.vote_count for channel_vote in store.votes)
store.lastModified = datetime.datetime.now()
if request.headers.getlist("X-Forwarded-For"):
store.last_ip = request.headers.getlist("X-Forwarded-For")[0]
else:
store.last_ip = request.remote_addr
if store.disable_vote >= vote_sum * disable_threshold:
store.enable = False
success = store.update()
if success:
if store.enable:
result = store_schema.dump(store)
return jsonify(result.data), 204
else:
return jsonify({}), 204
else:
return Response(status=500)
return Response(status=404)
def user_with_product():
new_user = User.create("*****@*****.**", "pass")
store = Store(name="Test Store", user=new_user)
product = Product(name='Test Product',
description='a product',
store=store)
db.session.add(product)
db.session.commit()
yield new_user
def get_stores(id):
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 10, type=int), 100)
data = Store.to_collection_dict(Store.query,
g.current_user.id,
page,
per_page,
'api.get_stores')
return jsonify(data)
def test_to_json(self):
s = Store(store_id=12,
store_name='Local Space',
address_line_one='3452 W Adams St',
address_line_two='Suite #7',
city='Chicago',
state='IL',
zip='60603')
db.session.add(s)
db.session.commit()
with self.app.test_request_context('/'):
json_user = s.to_json()
expected_keys = [
'url', 'store_id', 'store_name', 'address_line_one',
'address_line_two', 'city', 'state', 'zip'
]
self.assertEqual(sorted(json_user.keys()), sorted(expected_keys))
self.assertEqual('/api/v1/users/' + str(s.store_id), json_user['url'])
def create_store(name="Example Store", num_products=0):
store = Store(name=name)
for index in range(num_products):
product = Product(name="Product {}".format(index),
description="example",
store=store)
db.session.add(product)
db.session.add(store)
db.session.commit()
return store
def post(self):
try:
user = check_user_session(request)
store = request.json
new_store = Store(name=store['name'],
category_id=store['category'],
description=store['description'],
departament_id=int(store['departament']),
email=store['email'],
phone_number=store['phone_number'],
user=user,
user_id=user.id)
# new_store.user_id = user.id
if not new_store:
raise Exception('Failed to create a new Store')
db.session.add(new_store)
db.session.commit()
return {
'status':
'ok',
'store':
new_store.to_dict(rules=('-user', '-user_id', '-products',
'-category', '-departament')),
'user':
user.to_dict(rules=('-password', '-id', '-comments', '-store',
'-likes'))
}, 201
except jwt.ExpiredSignatureError as e:
return {'status': 'fail', 'message': str(e)}, 401
except IntegrityError as e:
return {
'status': 'fail',
'message': 'A user can only have a store'
}, 400
except Exception as e:
print(str(e))
return {'status': 'fail', 'message': str(e)}, 400
def test_post_new_cart(self):
with self.app.app_context():
res = self.client.post('/cart/store/1')
self.assertEqual(404, res.status_code)
store = Store(name='Test Store')
db.session.add(store)
db.session.commit()
res = self.client.post(f'/cart/store/{store.id}')
self.assertEqual(201, res.status_code)
self.assertIn(b'id', res.data)
self.assertIn(b'store_id', res.data)
self.assertTrue(self.is_json_content_type(res.content_type))
def test_get_product_availability_at_store(self):
with self.app.app_context():
res = self.client.get('store/1/product')
self.assertEqual(404, res.status_code)
store = Store(name='TestStore')
db.session.add(store)
db.session.commit()
res = self.client.get(f'store/{store.id}/product')
self.assertEqual(200, res.status_code)
self.assertTrue(self.is_json_content_type(res.content_type))
self.assertIn(b'id', res.data)
self.assertIn(b'name', res.data)
self.assertIn(b'products', res.data)
def setup():
with app.app_context():
db.create_all()
user = User.create("*****@*****.**", "test")
db.session.add(user)
store = Store(name="Test store", user=user)
for i in range(2):
prod = Product(name='Test Book v{}'.format((1 + i) * 2),
description='Book #{} in the series'.format(i + 1),
price_cents=10000 * (i + 1),
store=store)
db.session.add(prod)
db.session.commit()
def authenticated_request(client):
new_user = User.create("*****@*****.**", "examplepass")
store = Store(name="Test Store", user=new_user)
db.session.add(store)
db.session.commit()
response = client.post(url_for('user.login'),
data={
'email': "*****@*****.**",
'password': "******"
},
follow_redirects=True)
yield new_user
def test_get_product_information_from_store(self):
with self.app.app_context():
res = self.client.get('/product/1/store/1', follow_redirects=True)
self.assertEqual(404, res.status_code)
product = Product(name='Test Product', price=10)
store = Store(name='Test Store')
link = ProductStoreLink(product=product, stock=5)
store.products.append(link)
db.session.add(store)
db.session.commit()
res = self.client.get(f'/product/{product.id}/store/{store.id}',
follow_redirects=True)
self.assertEqual(200, res.status_code)
self.assertTrue(self.is_json_content_type(res.content_type))
def dummy():
# Create a user if they do not exist.
user = User.query.filter_by(email="*****@*****.**").first()
if not user:
user = User("*****@*****.**", "123456")
user.save()
for i in range(100):
# Add stores to the database
store = Store(faker.name.industry(), user.id)
store.save()
for stor in range(1000):
# Add items to the store
stor = Store.query.filter_by(id=randint(1,
Store.query.count() -
1)).first()
item = StoreItem(faker.name.company_name(), faker.lorem_ipsum.word(),
buckt.id)
db.session.add(item)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
def test_add_product_to_cart(self):
with self.app.app_context():
res = self.client.post('/cart/1/product/1')
self.assertEqual(404, res.status_code)
store = Store(name='Test Store')
product = Product(name='Test Product', price=10)
db.session.add(store)
db.session.add(product)
db.session.commit()
cart = Cart(store_id=store.id)
db.session.add(cart)
db.session.commit()
res = self.client.post(f'/cart/{cart.id}/product/{product.id}')
self.assertEqual(200, res.status_code)
self.assertIn(b'There is no stock of this product at this store',
res.data)
self.assertTrue(self.is_json_content_type(res.content_type))
def register():
if current_user.is_authenticated:
flash("You are already logged in", 'warning')
return redirect(url_for("products.index"))
form = SignupForm()
if form.validate_on_submit():
user = User.create(form.email.data, form.password.data)
store = Store(name=form.store_name.data, user=user)
db.session.add(store)
db.session.commit()
login_user(user)
send_pretty_welcome_message(user)
flash("Registered succesfully.", "success")
return redirect(session.get('after_login') or url_for("products.index"))
return render_template("users/register.html", form=form)
def additem(): # Add an item to store
if current_user.is_anonymous: # Parameters: None
return redirect(404) # Returns: store_add.html file and passes in the add_item_to_store form
else: # Purpose: To add a new item to the store but you must be an admin to do so,
for i in User.query.all(): # it checks this before displaying the page
if i.username == current_user.username:
if i.accesslevel >= 2:
form = add_item_to_store()
if form.validate_on_submit():
for item in Store.query.all():
print(item.id, "HE")
print(form.item_id.data)
if int(item.id) == int(form.item_id.data):
flash("That ID Is In Use")
return redirect(url_for("additem"))
item = Store(
id=form.item_id.data,
name=form.name.data,
image=form.image.data,
back_image=form.back_image.data,
cat=form.catagory.data,
price=form.price.data,
sale=form.sale.data,
cost=0
)
db.session.add(item)
db.session.commit()
item = stock(
itemid=form.item_id.data,
size=form.size.data,
stock=form.stock.data,
colour=form.colour.data,
bought=0
)
db.session.add(item)
db.session.commit()
flash("Item Added To The Store")
return redirect(url_for("admin"))
else:
print(form.errors)
else:
return redirect(url_for(404))
return render_template("store/store_add.html", title="Admin-", form=form)
def edit_store(store_id):
request_data = request.form
s = Store.get_by_id(store_id)
s.name = request_data['name']
s.lat = float(request_data['lat'])
s.lng = float(request_data['lng'])
s.address = request_data['address']
s.news = request_data['news']
s.switchable = str2bool(request_data['switchable'])
s.lastModified = datetime.datetime.now()
s.ip = request.remote_addr
success = s.update()
if success:
return Response(status=204)
else:
return Response(status=500)
def get_store_list() -> Response:
try:
args = request.args
lat = args['lat']
lng = args['lng']
name = args.get('name', '')
radius = args.get('radius', 5000.0)
page = args.get('page', 1)
store_list, count = Store.read_list(lat=lat,
lng=lng,
name=name,
radius=radius,
page=page)
result = stores_schema.dump(store_list)
return jsonify({'result': result.data, 'total': count}), 200
except KeyError:
return Response(status=400)
except Exception as e:
print(e)
return Response(status=500)
def test_apply_voucher_to_cart(self):
with self.app.app_context():
res = self.client.get('/cart/1/voucher/1')
self.assertEqual(404, res.status_code)
store = Store(name='Test Store')
db.session.add(store)
db.session.commit()
today = date.today()
voucher = Voucher(code='TESTCODE',
store_id=store.id,
start_date=today,
end_date=today + timedelta(days=5))
cart = Cart(store_id=store.id)
db.session.add(cart)
db.session.add(voucher)
db.session.commit()
res = self.client.get(f'/cart/{cart.id}/voucher/{voucher.id}')
self.assertEqual(200, res.status_code)
self.assertIn(b'original_price', res.data)
self.assertIn(b'discounted_price', res.data)
self.assertTrue(self.is_json_content_type(res.content_type))
def test_remove_product_from_cart(self):
with self.app.app_context():
res = self.client.delete('/cart/1/product/1')
self.assertEqual(404, res.status_code)
store = Store(name='Test Store')
product = Product(name='Test Product', price=10)
link = ProductStoreLink(product=product, stock=5)
store.products.append(link)
db.session.add(store)
db.session.add(product)
db.session.commit()
cart = Cart(store_id=store.id)
link = CartProductLink(product=product, units=2)
cart.products.append(link)
db.session.add(cart)
db.session.commit()
res = self.client.delete(f'/cart/{cart.id}/product/{product.id}')
self.assertEqual(200, res.status_code)
self.assertIn(b'id', res.data)
self.assertIn(b'store_id', res.data)
self.assertIn(b'products', res.data)
self.assertTrue(self.is_json_content_type(res.content_type))
def test_get_item(self):
item_store = ItemStore(item_id=12, store_id=14)
item = Item(item_id=12,
item_name='hat',
item_description='goes on head',
category='clothing',
artisan_id=14)
store = Store(store_id=12,
store_name='Local Space',
address_line_one='3452 W Adams St',
address_line_two='Suite #7',
city='Chicago',
state='IL',
zip='60603')
db.session.add(item_store)
db.session.add(item)
db.session.add(store)
db.session.commit()
expected_keys = ['item', 'stores']
self.assertEqual(sorted(get_item(item.item_id).keys()),
sorted(expected_keys))
