def test_func_it_works(self):
business1 = Business(name='name',
password='******',
email='email',
confirmed=True)
business2 = Business(name='name',
password='******',
email='email',
confirmed=True)
business2.registered_on -= timedelta(days=32)
business3 = Business(name='name',
password='******',
email='email',
confirmed=False)
business3.registered_on -= timedelta(days=32)
business4 = Business(name='name',
password='******',
email='email',
confirmed=False)
db.session.add(business1)
db.session.add(business2)
db.session.add(business3)
db.session.add(business4)
db.session.commit()
self.assertTrue(Business.it_works(business1.id))
self.assertTrue(Business.it_works(business2.id))
self.assertFalse(Business.it_works(business3.id))
self.assertTrue(Business.it_works(business4.id))
def test_func_account_is_old(self):
business1 = Business(name='name',
password='******',
email='email',
confirmed=True)
business2 = Business(name='name',
password='******',
email='email',
confirmed=True)
business2.registered_on -= timedelta(days=32)
db.session.add(business1)
db.session.add(business2)
db.session.commit()
self.assertFalse(Business.account_is_old(business1.id))
self.assertTrue(business2.id)
def test_func_get_all(self):
business1 = Business(name='name',
password='******',
email='email',
confirmed=True)
business2 = Business(name='name2',
password='******',
email='email2',
confirmed=False)
db.session.add(business1)
db.session.add(business2)
db.session.commit()
businesses = Business.get_all()
self.assertEqual(businesses[0], business1)
self.assertEqual(businesses[1], business2)
def test_func_check_confirmed(self):
business = Business(name='name',
password='******',
email='email',
confirmed=True)
db.session.add(business)
db.session.commit()
self.assertTrue(Business.check_confirmed(business.id))
next_business = Business(name='name',
password='******',
email='email',
confirmed=False)
db.session.add(next_business)
db.session.commit()
self.assertFalse(Business.check_confirmed(next_business.id))
def create_business():
'''register a business'''
current_user = get_jwt_identity()
bizdata = request.get_json()
new_business = Business(
bizdata["bizname"],
bizdata["bizlocation"],
bizdata["bizcategory"],
current_user
)
new_business.save()
# this displays the created business layout
business_info[new_business.id]={
"bizID": new_business.id,
"bizname": new_business.bizname,
"bizlocation":new_business.bizlocation,
"bizcategory": new_business.bizcategory,
"owner": current_user
}
response = {"message": "you have registered a business",
"business": business_info[new_business.id]
}
return make_response(jsonify(response),201)
def post(self):
if self.validate_json():
return self.validate_json()
data = request.get_json()
name = data.get('name')
category = data.get('category')
location = data.get('location')
current_user = get_jwt_identity()
data_ = dict(name=name, category=category, location=location)
if self.validate_null(**data_):
return self.validate_null(**data_)
user_ = [user for user in users if current_user == user.email]
if not user_:
response = {'message': 'Login in to register business'}
return jsonify(response), 401
data = self.remove_extra_spaces(**data_)
available = [
business for business in store if data['name'] == business.name
]
if available:
name = data['name']
response = {'message': f'Business with name {name} already exists'}
return jsonify(response), 409
business = Business(**data, created_by=current_user)
store.append(business)
response = {'message': 'Business with name {} created'.format(name)}
return jsonify(response), 201
def createQuery(row):
business_id = row.get("business_id")
name = row.get("name")
neighborhood = row.get("neighborhood")
address = row.get("address")
city = row.get("city")
state = row.get("state")
postal_code = row.get("postal_code")
latitude = row.get("latitude")
longitude = row.get("longitude")
stars = row.get("stars")
is_open = row.get("is_open")
review_count = row.get("review_count")
attributes = json.dumps(row.get("attributes"))
categories = row.get("categories")
hours = json.dumps(row.get("hours"))
# queryStr = "INSERT INTO business (business_id, name, neighborhood, address, city, state, postal_code, latitude, longitude, stars, review_count, is_open, attributes, categories, hours) VALUES ('%s', '%s', '%s', '%s', '%s', '%s','%s', %s, %s, %s, %s, %s, '%s', '%s', '%s')" %(business_id, name, neighborhood, address, city, state, postal_code, latitude, longitude, stars, review_count, is_open, attributes, categories, hours)
obj = Business(business_id=business_id,
name=name,
neighborhood=neighborhood,
address=address,
city=city,
state=state,
postal_code=postal_code,
latitude=latitude,
longitude=longitude,
stars=stars,
is_open=is_open,
review_count=review_count,
attributes=attributes,
categories=categories,
hours=hours)
print(obj)
def create_business():
'''register a business'''
data = request.get_json()
# get the user name using jwt
current_user=get_jwt_identity()
new_business = Business(
data["business_name"],
data["business_location"],
data["business_category"],
current_user
)
new_business.validate_business_name()
#this adds the created business to a list of all businesses
new_business.save()
# print(business_info)
business_info[new_business.business_ID] = {
"business_ID": new_business.business_ID,
"business_name": new_business.business_name,
"business_location": new_business.business_location,
"business_category": new_business.business_category,
"owner": current_user
}
response = {"message": "you have registered a business",
"business": business_info[new_business.business_ID]
}
return make_response(jsonify(response),201)
def post(self):
"""Endpoint to save the data to the database"""
data = request.get_json()
name = data.get('name')
description = data.get('description')
category = data.get('category')
location = data.get('location')
user_id = get_jwt_identity()
data = dict(name=name,
description=description,
category=category,
location=location)
if check_missing_field(**data):
return jsonify(check_missing_field(**data)), 422
user = User.query.filter_by(id=user_id).first()
name = remove_more_spaces(name)
description = remove_more_spaces(description)
if not user:
return self.generate_response(messages['valid_login'], 403)
business = Business(name, description, category, location, user_id)
business.save()
return self.generate_response(messages['business_created'], 201)
def test_func_get_email(self):
business = Business(name='name',
password='******',
email='email',
confirmed=True)
db.session.add(business)
db.session.commit()
self.assertEqual(business.email, Business.get_email(business.id))
def test_func_save(self):
business = Business(name='name',
password='******',
email='email',
confirmed=True)
business.save()
committed_business = Business.query.get(business.id)
self.assertEqual(business, committed_business)
def registerBusiness():
""" This is to register a business"""
current_user = get_jwt_identity()
if request.method == 'POST':
# Check for blank key
try:
required_fields = ['name', 'description', 'category', 'location']
data = check_blank_key(request.get_json(), required_fields)
except AssertionError as err:
msg = err.args[0]
return jsonify({"message": msg}), 422
# Check if user entered a name and location
name = validate_buss_data_null(data['name'])
description = validate_buss_data_null(data['description'])
location = validate_buss_data_null(data['location'])
category = validate_buss_data_null(data['category'])
if not location or not description or not name:
return jsonify(
{'message': 'You need a business name' +
' and location to Register'}), 403
# Check if business is registered
exist_business = Business.query.filter_by(name=name).first()
if exist_business:
return jsonify(
{'message': 'This Business is already registered'}), 409
new_business = Business(
name=name,
description=description,
category=category,
location=location,
user_id=current_user)
new_business.save()
current_business = Business.query.filter_by(
name=name).first()
new_business_id = current_business.id
new_business_name = current_business.name
return jsonify(
{'message': 'New business has been created',
'businesses ID': new_business_id,
'business name': new_business_name
}), 201
# Get all businesses
all_businesses = Business.get_all(Business)
def func(business): return business.accesible()
all_businesses = map(func, all_businesses)
data = list(all_businesses)
if data == []:
return jsonify({'message': 'No businesses available',
}), 200
return jsonify({'message': 'These are the businesses',
'businesses': data
}), 200
def test_func_email_is_free(self):
business = Business(name='name',
password='******',
email='email',
confirmed=True)
business.registered_on -= timedelta(days=32)
db.session.add(business)
db.session.commit()
self.assertTrue(Business.email_is_free('email1'))
self.assertFalse(Business.email_is_free('email'))
def setUp(self):
db.create_all()
user = User(first_name='Mikael', middle_name='Bloomberg', last_name='Bloomy', username='******', email='*****@*****.**')
user.set_password('bloomy')
db.session.add(user)
db.session.commit()
business = Business(name='testName1', category='testCat1', desctiption='testDesc1', location='Area 51', user_id=1)
db.session.add(business)
db.session.commit()
user2 = User(first_name='John', middle_name='Anderson', last_name='Wick', username='******', email='*****@*****.**')
user2.set_password('jwick')
db.session.add(user2)
db.session.commit()
business2 = Business(name='testName2', category='testCat2', desctiption='testDesc2', location='Area 52', user_id=2)
db.session.add(business2)
db.session.commit()
review = Review(user_id=2, business_id=1, post='testReview1')
db.session.add(review)
db.session.commit
def new_post():
"""function for creating a new business"""
form = BusinessForm()
if form.validate_on_submit():
business = Business(title=form.title.data,
content=form.content.data,
business=current_user)
db.session.add(business)
db.session.commit()
flash('Your business has been created!', 'success')
return redirect(url_for('home'))
return render_template('create_post.html',
title='New Business',
form=form,
legend='New Business')
def add():
form = BusinessForm()
if form.validate_on_submit():
business_active = form.active.data
business_name = re.sub('[^A-Za-z0-9_]+', '', form.buname.data)
business_domain = re.sub('[^A-Za-z0-9_]+', '', form.domain.data)
business = Business(name=business_name,
active=business_active,
domain=business_domain)
db.session.add(business)
db.session.commit()
return redirect(url_for('business.index'))
def register_business():
if request.method == 'POST':
current_user = get_jwt_identity()
biz_data = request.get_json()
business_name = biz_data.get('business_name')
category = biz_data.get('category')
location = biz_data.get('location')
description = biz_data.get('description')
biz = Business.business.items()
existing_business = {
k: v
for k, v in biz if biz_data['business_name'] in v['business_name']
}
if business_name == "":
return jsonify(
{'message':
'Business name should not be an empty string'}), 406
elif category == "":
return jsonify(
{'message': 'Category should not be an empty string'}), 406
elif location == "":
return jsonify(
{'message': 'Location should not be an empty string'}), 406
elif description == "":
return jsonify(
{'message': 'Description should not be an empty string'}), 406
elif existing_business:
return jsonify({"message": "Business name already exists"})
else:
new_biz = Business(business_name, category, location, description,
current_user)
new_biz.register_business()
response = {
'message': 'Business Successfully Registered',
'Registered by': current_user
}
return make_response(jsonify(response)), 201
#If GET method
businesses = Business.get_all_businesses()
return make_response(jsonify(businesses)), 200
def business_signup():
print("In Business register")
if request.method == 'POST':
print("Register Sub")
data = request.get_json()
print("REQUEST data:")
print(request.form)
hashed_password = generate_password_hash(request.form['password'],
method='sha256')
num = str(uuid.uuid4())
new_user = Business(public_id=num,
name=request.form['name'],
email=request.form['email'],
username=request.form['username'],
password=hashed_password,
location=request.form['location'])
new_user_1 = BusinessDetails(public_id=num,
verifier=False,
rule1=False,
rule2=False,
rule3=False,
adnl_rule="adnl rule")
try:
db.session.add(new_user)
db.session.commit()
print(new_user)
db.session.add(new_user_1)
db.session.commit()
print(new_user_1)
return redirect(url_for('business_login'))
#return render_template('home.html', title='Sign Up')
except:
return jsonify({'message': 'Unsuccessful registration'})
# return render_template('signup.html', title='Sign Up')
return render_template('business_register.html',
title='Business sign up page')
def createBusiness():
data = request.json
business = Business(
user_id=data['user_id'],
name=data['name'],
description=data['description'],
lat=data['lat'],
lng=data['lng'],
address=data['address'],
city=data['city'],
state=data['state'],
zipcode=data['zipcode'],
website=data['website'],
contact=data['contact'],
imgURL=data['imgURL'],
)
db.session.add(business)
db.session.commit()
return business.to_dict()
def email_list():
form = EmailForm()
if request.method == "POST":
if recaptcha.verify():
if form.validate_on_submit():
if Business.query.filter_by(email=form.email.data).first():
flash("You are already signed up for our email list.",
"error")
return redirect(url_for("index"))
else:
business_to_add = Business(email=form.email.data)
db.session.add(business_to_add)
db.session.commit()
flash("Thank you for signing up for our email list!",
"success")
return redirect(url_for("index"))
else:
flash("Please fill out the recaptcha form.", "error")
return render_template("email_list/email_list.html", form=form)
def addbusiness():
""" route enables user add a business"""
error = None
if request.method == 'POST':
name = request.form['business_name']
category = request.form['category']
location = request.form['location']
business = Business.query.filter_by(business_name = name, business_category = category, business_location = location).first()
if business:
error = 'Business already exists!'
return render_template('addBusiness.html', error = error)
newbusiness = Business(business_name = name, business_category = category, business_location = location, user_id = current_user.id)
db.session.add(newbusiness)
db.session.commit()
flash('new business added!')
return redirect(url_for('viewbusiness'))
return render_template('addBusiness.html', error = error)
def index():
form = BusinessForm()
business = Business.query.order_by(Business.id.desc()).all()
bu = Business()
columns = bu.serialize_columns()
bus = []
for b in business:
bus.append(b.as_dict())
base_url = url_for('business.index')
action_url = url_for('business.add')
return render_template('business.html',
title='Business',
rows=bus,
columns=columns,
base_url=base_url,
action_url=action_url,
per_page=current_app.config['ROWS_PER_PAGE'],
form=form)
def business():
if request.method == 'POST':
"""gets data from request and save business"""
name = str(request.data.get('name', ''))
description = str(request.data.get('description', ''))
location = str(request.data.get('location', ''))
contact = str(request.data.get('contact', ''))
if name and description and location and contact:
"""validate that it is not duplicate"""
validateName = Business.check_name_exists(name)
validateContact = Business.check_contact_exists(contact)
validName = Business.validate_business_name(name)
validLocation = Business.validate_business_description(
location)
validContact = Business.validate_business_contact(contact)
if validateName:
response = jsonify({
"message": "Business name already exists",
"status_code": 400
})
response.status_code = 400
return response
elif validateContact:
response = jsonify({
"message":
"Business contact already exists use different contact",
"status_code": 400
})
response.status_code = 400
return response
elif validName:
response = jsonify({
"message": "Enter business name",
"status_code": 400
})
response.status_code = 400
return response
elif validLocation:
response = jsonify({
"message": "Enter business location",
"status_code": 400
})
response.status_code = 400
return response
elif validContact:
response = jsonify({
"message": "Enter business contact",
"status_code": 400
})
response.status_code = 400
return response
else:
"""create business object"""
business = Business(name=name,
description=description,
location=location,
contact=contact)
new_business = business.save_business(
name, description, location, contact)
response = jsonify(new_business)
response.status_code = 201
return response
elif not name:
response = jsonify({
"message": "name is missing",
"status_code": 400
})
response.status_code = 400
return response
elif not description:
response = jsonify({
"message": "description missing",
"status_code": 400
})
response.status_code = 400
return response
elif not location:
response = jsonify({
"message": "business location is missing",
"status_code": 400
})
response.status_code = 400
return response
else:
response = jsonify({
"message": "business contact is missing",
"status_code": 400
})
response.status_code = 400
return response
else:
"""if its a get request"""
Businesses = Business.get_all_businesses()
print(Businesses)
if not Businesses:
response = jsonify({
"message": "business does not exist",
"status": 200
})
response.status_code = 200
response = jsonify({
"message": "business does not exist",
"status": 400
})
response.status_code = 400
return response
response = jsonify({"businesses": Businesses})
response.status_code = 200
return response
def businesses(current_user):
""" route allows user register a business and view all registered businesses """
if request.method == 'POST':
''' registering new business '''
data = request.get_json()
is_valid_name = re.match('^[A-Za-z]+[A-Za-z0-9 ]+$',
data['business_name'])
is_valid_category = re.match('^[A-Za-z]+[A-Za-z0-9 ]+$',
data['category'])
is_valid_location = re.match('^[A-Za-z]+[A-Za-z0-9 ]+$',
data['location'])
if not (is_valid_name and is_valid_category and is_valid_location):
return jsonify({
'Message': 'Only characters and digits are expected!',
'Status': 'Failed'
}), 403
biz_name = data['business_name'].lower()
business = Business.query.filter_by(business_name=biz_name).first()
if business is not None:
return jsonify({
'Message': 'Business registered already',
'Status': 'Failed'
}), 202
new_business = Business(business_name=data['business_name'],
category=data['category'],
location=data['location'],
user_id=current_user)
db.session.add(new_business)
db.session.commit()
return jsonify({
'Message':
data['business_name'].upper() + ' Registered Successfully',
'Status': 'Success'
}), 201
else:
name = request.args.get('q', None)
limit = request.args.get('limit', None, type=int)
page = request.args.get('page', 1, type=int)
location = request.args.get('location', None)
category = request.args.get('category', None)
if limit is not None:
business_results = Business.query.paginate(page, limit, False)
response = {
'Businesses':
[i.business_object() for i in business_results.items],
'pages': business_results.pages,
'next': business_results.next_num,
'current': business_results.page,
'prev': business_results.prev_num,
'count': business_results.total
}
return jsonify(response), 200
elif name is not None:
businesses = Business.query.filter(
Business.business_name.ilike('%' + name + '%'))
business_list = [
business.business_object() for business in businesses
]
return jsonify({
'Status': 'Success',
'Businesses': business_list
}), 200
elif location is not None:
businesses = Business.query.filter(
Business.location.ilike('%' + location + '%'))
business_list = [
business.business_object() for business in businesses
]
return jsonify({
'Status': 'Success',
'Businesses': business_list
}), 200
elif category is not None:
businesses = Business.query.filter(
Business.category.ilike('%' + category + '%'))
business_list = [
business.business_object() for business in businesses
]
return jsonify({
'Status': 'Success',
'Businesses': business_list
}), 200
#GET without params
businesses = Business.get_businesses()
business_list = [business.business_object() for business in businesses]
return jsonify({'Status': 'Success', 'Businesses': business_list}), 200
def post(self):
"""Register a business.
---
tags:
- businesses
parameters:
- in: header
name: authorization
description: JSON Web Token
type: string
required: true
x-authentication: Bearer
- in: body
name: body
schema:
id: Business
required:
- name
- category
- location
- summary
properties:
name:
type: string
description: Unique business name
category:
type: string
description: businesses with the same features
location:
type: string
description: Business physical location
summary:
type: string
description: Describes the business
responses:
201:
description: Business has been registered successfully!
schema:
properties:
response_message:
type: string
status_code:
type: integer
406:
description: Violate business column constraints
schema:
properties:
response_message:
type: string
"""
req_data = request.get_json(force=True)
business_name = req_data.get('name')
business_category = req_data.get('category')
business_location = req_data.get('location')
business_summary = req_data.get('summary')
created_by = get_jwt_identity()
if not business_name or not business_summary:
response = jsonify({
'response_message':
'Business name and description are required!',
'status_code': 406
})
return response
if not business_location or not business_category:
response = jsonify({
'response_message':
'Business location and category are required!',
'status_code': 406
})
return response
if not business_name_registered(business_name):
try:
business = Business(business_name, business_category,
business_location,
business_summary, created_by)
business.save()
response = jsonify({
'response_message':
'Business has been registered successfully!',
'status_code': 201
})
return response
except Exception as error:
response_message = {
'message': str(error),
'status_code': 500}
return make_response(jsonify(response_message))
else:
response = jsonify({
'response_message': 'Business name already registered!',
'status_code': 406
})
return response
def test_business_repr(self):
business = Business(user_id=1,
name='business 1',
location='location 1',
description='business description')
self.assertTrue(business.__repr__() == "Business name 'business 1'")
def get_business():
b = Business()
business = b.get_business()
return jsonify({'data': business})
def setUp(self):
Business.business = {}
self.bizna = Business("Mutura kwa Maiko", "Restaurant", "Kiamaiko",
"Best Mutura in town", "Kelvin")