def generate_bill(from_day, to_day):
f = calendar.timegm(from_day.timetuple()) * 1000000000
t = calendar.timegm(to_day.timetuple()) * 1000000000
collection = db['users']
users = collection.find({})
for user in users:
u = User(user)
bill = Bill(u, from_day, to_day)
for device in u.devices:
measurements = get_measurements(device, f, t, None, "job")
bill.fill_measurements(device, measurements)
total = 0
for m in measurements:
total += m["value"]
bill.waterflow = total
bill.price = total * 0.015
insert_json = {
"username": bill.username,
"date": bill.to_date.strftime("%Y-%m-%d"),
"waterflow": bill.waterflow,
"price": bill.price
}
db.bills.insert(insert_json)
def signup_admin():
# let's inicizlize db
db.init_app(app)
# let's create db
with app.app_context():
db.create_all()
name = 'admin'
password = '******'
user = User.query.filter_by(name=name).first(
) # if this returns a user, then the email already exists in database
if user: # if a user is found, we want to redirect back to signup page so user can try again
# return redirect(url_for('auth.signup'))
return 'it is ALREADY exists ADMIN'
# create new user with the form data. Hash the password so plaintext version isn't saved.
new_user = User(public_id=str(uuid.uuid4()),
name=name,
password=generate_password_hash(password,
method='sha256'),
admin=True)
# add the new user to the database
db.session.add(new_user)
db.session.commit()
def test_login_valid_details_user(self):
"""
user = {
"fname": "toast",
"lname": "bull",
"email": "*****@*****.**",
"password": "******"
}
response = self.app.post("/bookmealapi/v1.0/auth/signup",\
data=json.dumps(user), content_type='application/json')
"""
first_name = "toast"
last_name = "bull"
email = "*****@*****.**"
password = "******"
hashed_password = generate_password_hash(password, method='sha256')
new_user = User(first_name=first_name, last_name=last_name,\
email=email, password=hashed_password)
db.session.add(new_user)
db.session.commit()
""" correct details """
details = {"email": "*****@*****.**", "password": "******"}
response = self.app.post("/bookmealapi/v1.0/auth/login",\
data=json.dumps(details), content_type='application/json')
data = json.loads(response.get_data())
self.assertEqual(response.status_code, 200)
data = json.loads(response.get_data())
self.assertEqual(data['message'], "Successfully login")
def test_get_all_meals(self):
""" Get all meals """
business_name = "FAST FOOD"
location = "nakulabye"
first_name = "atlas"
last_name = "waters"
email = "*****@*****.**"
password = "******"
role_id = 1
hashed_password = generate_password_hash(password, method='sha256')
new_admin = User(first_name= first_name, last_name=last_name,\
email=email, password= hashed_password, role_id=role_id,\
business_name=business_name, location=location)
db.session.add(new_admin)
db.session.commit()
meal_name = "katogo"
price = 2000
meal_type = "breakfast"
meal = Meals(meal_name=meal_name, price=price, meal_type=meal_type)
db.session.add(meal)
db.session.commit()
details = {"email": "*****@*****.**", "password": "******"}
response = self.app.post("/bookmealapi/v1.0/auth/login",\
data=json.dumps(details), content_type='application/json')
data = json.loads(response.get_data())
token = data['token']
response = self.app.get('/bookmealapi/v1.0/meals',\
headers={'x-access-token' : token})
data = json.loads(response.get_data())
self.assertEqual(response.status_code, 200)
self.assertEqual(len(data['meals']), 1)
def register():
# app.logger.info("inside register")
# app.logger.info(request.json)
if not request.json or not 'email' in request.json:
nobj = Notification()
nobj.setdata(True, "Wrong Email or password !!", None)
return buildresponse(nobj, {'http_status': 400})
else:
user = User()
# app.logger.info("after user--form")
# app.logger.debug(request.form)
# app.logger.info("in register, calling save {},{},{}".format(request.form['email'],request.form['name'],request.form['pwd']) )
# app.logger(request.form["email"])
nobj = user.login(db.connection, request.json['email'],
request.json['pwd'])
if nobj.result is None:
nobj = user.save(db.connection, request.json['email'],
request.json['name'], request.json['pwd'])
if not nobj.haserrors and nobj.result is not None:
nobj.result = {}
resobj = user.getfeedtree(db.connection, request.json['email'])
if not resobj.haserrors:
nobj.result["feedlist"] = resobj.result
resobj = user.getcategorylist(db.connection,
request.json['email'])
if not resobj.haserrors:
nobj.result["categories"] = resobj.result
# app.logger.info("returning response")
return buildresponse(nobj, {'http_status': 201})
def test_update_order_price_string(self):
""" Price cannot be string """
business_name = "FAST FOOD"
location = "nakulabye"
first_name = "atlas"
last_name = "waters"
email = "*****@*****.**"
password = "******"
role_id = 1
hashed_password = generate_password_hash(password, method='sha256')
new_admin = User(first_name= first_name, last_name=last_name,\
email=email, password= hashed_password, role_id=role_id,\
business_name=business_name, location=location)
db.session.add(new_admin)
db.session.commit()
details = {"email": "*****@*****.**", "password": "******"}
response = self.app.post("/bookmealapi/v1.0/auth/login",\
data=json.dumps(details), content_type='application/json')
self.assertEqual(response.status_code, 200)
data = json.loads(response.get_data())
token = data['token']
details = {"meal_name": "katogo", "price": "8000"}
response = self.app.put("/bookmealapi/v1.0/orders/2",\
data=json.dumps(details), content_type='application/json',\
headers={'x-access-token' : token})
self.assertEqual(response.status_code, 400)
def test_select_meal_valid(self):
""" valid json """
first_name = "atlas"
last_name = "waters"
email = "*****@*****.**"
password = "******"
role_id = 2
hashed_password = generate_password_hash(password, method='sha256')
new_user = User(first_name= first_name, last_name=last_name,\
email=email, password= hashed_password, role_id=role_id)
db.session.add(new_user)
db.session.commit()
meal_name = "katogo"
price = 2000
meal_type = "breakfast"
meal = Meals(meal_name=meal_name, price=price, meal_type=meal_type)
db.session.add(meal)
db.session.commit()
""" correct details """
details = {"email": "*****@*****.**", "password": "******"}
response = self.app.post("/bookmealapi/v1.0/auth/login",\
data=json.dumps(details), content_type='application/json')
data = json.loads(response.get_data())
token = data['token']
details = {"meal_name": "katogo", "price": 2000, "userId": 1}
response = self.app.post("/bookmealapi/v1.0/orders",\
data=json.dumps(details), content_type='application/json',\
headers={'x-access-token' : token})
self.assertEqual(response.status_code, 201)
def test_set_menu(self):
""" setting the menu """
business_name = "FAST FOOD"
location = "nakulabye"
first_name = "atlas"
last_name = "waters"
email = "*****@*****.**"
password = "******"
role_id = 1
hashed_password = generate_password_hash(password, method='sha256')
new_admin = User(first_name= first_name, last_name=last_name,\
email=email, password= hashed_password, role_id=role_id,\
business_name=business_name, location=location)
db.session.add(new_admin)
db.session.commit()
""" correct details admin """
details = {"email": "*****@*****.**", "password": "******"}
response = self.app.post("/bookmealapi/v1.0/auth/login",\
data=json.dumps(details), content_type='application/json')
data = json.loads(response.get_data())
token = data['token']
"""
details = {
"meal_name": "rolex",
"price": 2000,
"meal_type": "breakfast"
}
"""
details = {"meal_ids": [1, 2, 3, 4], "user_id": 1}
response = self.app.post("/bookmealapi/v1.0/menu",
data=json.dumps(details), content_type='application/json',\
headers={'x-access-token' : token})
self.assertEqual(response.status_code, 201)
def feeddetails(**kwargs):
# app.logger.info(kwargs['email'])
# app.logger.info(request.args.get('feedurl'))
user = User()
nobj = user.getfeeddata(db.connection, kwargs['email'],
request.args.get('feedurl'))
return buildresponse(nobj, {'http_status': 200})
def changecategory(**kwargs):
user = User()
nobj = user.changecategory(db.connection, kwargs['email'],
request.json['url'], request.json['category'])
if not nobj.haserrors:
nobj = user.getfeedtree(db.connection, kwargs['email'])
return buildresponse(nobj, {'http_status': 200})
def post(self):
keys = ('username', 'password', 'email')
rjson = request.json
if rjson is None: return Response.missing_parameters()
if all(elem in rjson for elem in keys):
if '' in rjson.values():
return Response.invalid_arguments()
if User.objects(username=rjson['username']):
return Response.user_exists()
if User.objects(email=rjson['email']):
return Response.email_taken()
User(password=bcrypt.generate_password_hash(rjson['password']),
username=rjson['username'],
email=rjson['email']).save()
return make_response(
jsonify({
"status": "success",
"message": "user successful created"
}), 201)
else:
return Response.missing_parameters()
return Response.unexpected_error()
def createUser():
data = request.get_json(force=True)
hashed_password = generate_password_hash(data["password"], method="sha256")
try:
new_user = User(public_id=str(uuid.uuid4()),
username=data["username"],
email=data["email"],
password=hashed_password,
admin=False)
db.session.add(new_user)
db.session.commit()
except IntegrityError:
db.session.rollback()
return make_response("User already exists", 409)
token = jwt.encode(
{
"public_id": new_user.public_id,
"username": new_user.username
}, app.config["SECRET_KEY"])
print("Sending response")
return jsonify({
"token": token,
"username": new_user.username,
"pub_id": new_user.public_id
})
def seed_data():
prxyval = Helper.getconfigvalue('dev.cfg', 'http_proxy', None)
if prxyval is not None:
prxydict = {'http_proxy': prxyval}
else:
prxydict = None
dburl = Helper.getconfigvalue('dev.cfg', 'DATABASE_URI', None)
dbname = Helper.getconfigvalue('dev.cfg', 'DBNAME', None)
db = pymongo.MongoClient(dburl)[dbname]
emailid = "*****@*****.**"
user = User()
notobj = user.save(db, emailid, emailid, 'pwd')
notobj = user.addcategory(db, emailid, 'fun')
notobj = user.addcategory(db, emailid, 'money')
notobj = user.addfeed(db, emailid, 'http://raptitude.com/rss', 'fun',
prxydict)
notobj = user.addfeed(db, emailid,
'http://feeds.feedburner.com/typepad/sethsmainblog',
'fun', prxydict)
notobj = user.addfeed(db, emailid,
'http://feeds.feedburner.com/TheInvestorBlog',
'money', prxydict)
def test_delete_menu_non_existant_data(self):
""" Deleting menu that doesnt exist """
business_name = "FAST FOOD"
location = "nakulabye"
first_name = "atlas"
last_name = "waters"
email = "*****@*****.**"
password = "******"
role_id = 1
hashed_password = generate_password_hash(password, method='sha256')
new_admin = User(first_name= first_name, last_name=last_name,\
email=email, password= hashed_password, role_id=role_id,\
business_name=business_name, location=location)
db.session.add(new_admin)
db.session.commit()
details = {"email": "*****@*****.**", "password": "******"}
response = self.app.post("/bookmealapi/v1.0/auth/login",\
data=json.dumps(details), content_type='application/json')
data = json.loads(response.get_data())
token = data['token']
response = self.app.delete('/bookmealapi/v1.0/menu/10',\
headers={'x-access-token' : token})
self.assertEqual(response.status_code, 404)
def test_delete_order_data_exists(self):
""" Deleting an order """
business_name = "FAST FOOD"
location = "nakulabye"
first_name = "atlas"
last_name = "waters"
email = "*****@*****.**"
password = "******"
role_id = 1
hashed_password = generate_password_hash(password, method='sha256')
new_admin = User(first_name= first_name, last_name=last_name,\
email=email, password= hashed_password, role_id=role_id,\
business_name=business_name, location=location)
db.session.add(new_admin)
db.session.commit()
meal_name = "katogo"
price = 3000
process_status = "Pending"
user_id = 1
order = Orders(meal_name=meal_name, price=price, user_id=user_id,\
process_status=process_status)
db.session.add(order)
db.session.commit()
details = {"email": "*****@*****.**", "password": "******"}
response = self.app.post("/bookmealapi/v1.0/auth/login",\
data=json.dumps(details), content_type='application/json')
data = json.loads(response.get_data())
token = data['token']
response = self.app.delete('/bookmealapi/v1.0/orders/1',\
headers={'x-access-token' : token})
self.assertEqual(response.status_code, 200)
def test_get_menu_day(self):
""" Get menu for the day """
business_name = "FAST FOOD"
location = "nakulabye"
first_name = "atlas"
last_name = "waters"
email = "*****@*****.**"
password = "******"
role_id = 1
hashed_password = generate_password_hash(password, method='sha256')
new_admin = User(first_name= first_name, last_name=last_name,\
email=email, password= hashed_password, role_id=role_id,\
business_name=business_name, location=location)
db.session.add(new_admin)
db.session.commit()
""" To pass the test """
first_name = "atlas"
last_name = "waters"
email = "*****@*****.**"
password = "******"
hashed_password = generate_password_hash(password, method='sha256')
new_user = User(first_name=first_name, last_name=last_name,\
email=email, password=hashed_password)
db.session.add(new_user)
db.session.commit()
meal_ids = [6, 2, 7, 4]
meal_ids_string = ""
for ids in meal_ids:
meal_ids_string += ';%s' % ids
user_id = 1
menu = Menu(user_id=user_id, meal_ids=meal_ids_string)
db.session.add(menu)
db.session.commit()
details = {"email": "*****@*****.**", "password": "******"}
response = self.app.post("/bookmealapi/v1.0/auth/login",\
data=json.dumps(details), content_type='application/json')
data = json.loads(response.get_data())
token = data['token']
response = self.app.get('/bookmealapi/v1.0/menu',\
headers={'x-access-token' : token})
data = json.loads(response.get_data())
self.assertEqual(response.status_code, 200)
self.assertEqual(len(data['menu_day']), 1)
def setUp(self):
""" Création d'une base de données avant le test"""
warnings.filterwarnings('ignore', category=DeprecationWarning)
db.create_all()
user = User(username="******")
user.hash_password("admin")
db.session.add(user)
db.session.commit()
def check_auth(email, password):
"""This function is called to check if a username /
password combination is valid.
"""
# app.logger.info("in check auth {} , {}".format(email,password))
user = User()
ret = user.login(db.connection, email, password)
#app.logger.info(ret.haserrors)
#app.logger.info(ret.result)
return ret.result
def setUp(self):
self.app = app
self.ctx = self.app.app_context()
self.ctx.push()
db.drop_all()
db.create_all()
u = User(username=self.default_username)
u.set_password(self.default_password)
db.session.add(u)
db.session.commit()
self.client = TestClient(self.app, u.generate_auth_token(), '')
def updateitem(**kwargs):
if not request.json or not 'id' in request.json:
nobj = Notification()
nobj.setdata(True, "ID Not found!!", None)
return buildresponse(nobj, {'http_status': 400})
else:
user = User()
nobj = user.updatefeeditem(db.connection, kwargs['email'],
request.json['id'], request.json['isread'],
request.json['isstarred'])
return buildresponse(nobj, {'http_status': 200})
def update_doctor(doctor, data):
doctor.update(data)
if doctor.user:
doctor.user.update(data)
else:
user = User(
username=data.get('username'),
password=data.get('password'),
doctor_id=doctor.id
)
session.add(user)
session.commit()
def refreshfeed(**kwargs):
# app.logger.info(kwargs['email'])
feed = Feed()
nobj = feed.updatefeed(db.connection, request.args.get('feedurl'),
{'http_proxy': app.config['HTTP_PROXY']})
if not nobj.haserrors:
user = User()
nobj = user.getfeeddata(db.connection, kwargs['email'],
request.args.get('feedurl'))
# app.logger.info(nobj)
return buildresponse(nobj, {'http_status': 200})
def google_login_callback():
# Get authorization code Google sent back to you.
code = request.args.get("code")
# Find out what URL to hit to get tokens that allow you to ask for
# things on behalf of a user.
google_provider_cfg = get_google_provider_cfg()
token_endpoint = google_provider_cfg["token_endpoint"]
# Prepare and send a request to get tokens.
token_url, headers, body = client.prepare_token_request(
token_endpoint,
authorization_response=request.url,
redirect_url=request.base_url,
code=code)
token_response = requests.post(
token_url,
headers=headers,
data=body,
auth=(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET),
)
# Parse the tokens.
client.parse_request_body_response(json.dumps(token_response.json()))
# Find and hit the URL from Google that gives you the user's profile
# information, including their Google profile image and email.
userinfo_endpoint = google_provider_cfg["userinfo_endpoint"]
uri, headers, body = client.add_token(userinfo_endpoint)
userinfo_response = requests.get(uri, headers=headers, data=body)
if not userinfo_response.json().get("email_verified"):
print("User email not available or not verified by Google.")
return None
user_id = userinfo_response.json()["sub"]
user_name = userinfo_response.json()["given_name"]
user_email = userinfo_response.json()["email"]
user_picture = userinfo_response.json()["picture"]
# If the user is not already in our database, add them.
if not User.get(user_id):
User.create(user_id, user_name, user_email, user_picture)
# Begin user session
user = User(user_id, user_name, user_email, user_picture)
login_user(user)
return redirect('http://localhost:3000/')
def seed_data():
db = pymongo.MongoClient("localhost", 27017, safe=True).feedtest
emailid = "*****@*****.**"
user = User()
prxydict = {'http_proxy': 'http://www-proxy.au.oracle.com:80'}
notobj = user.save(db, emailid, emailid, 'pwd')
notobj = user.addcategory(db, emailid, 'fun')
notobj = user.addcategory(db, emailid, 'money')
notobj = user.addfeed(db, emailid, 'http://raptitude.com/rss', 'fun',
prxydict)
notobj = user.addfeed(db, emailid,
'http://feeds.feedburner.com/typepad/sethsmainblog',
'fun', prxydict)
notobj = user.addfeed(db, emailid,
'http://feeds.feedburner.com/TheInvestorBlog',
'money', prxydict)
def markasread(**kwargs):
# app.logger.info(kwargs['email'])
user = User()
nobj = user.markallread(db.connection, kwargs['email'],
request.json['feedurl'], request.json['ts'])
if not nobj.haserrors:
nobj.result = {}
resobj = user.getfeedtree(db.connection, kwargs['email'])
if not resobj.haserrors:
nobj.result['feedlist'] = resobj.result
resobj = user.getfeeddata(db.connection, kwargs['email'],
request.json['feedurl'])
if not resobj.haserrors:
nobj.result['feeddata'] = resobj.result
return buildresponse(nobj, {'http_status': 200})
def test_update_meal_option_valid(self):
""" correct values """
business_name = "FAST FOOD"
location = "nakulabye"
first_name = "atlas"
last_name = "waters"
email = "*****@*****.**"
password = "******"
role_id = 1
hashed_password = generate_password_hash(password, method='sha256')
new_admin = User(first_name= first_name, last_name=last_name,\
email=email, password= hashed_password, role_id=role_id,\
business_name=business_name, location=location)
db.session.add(new_admin)
db.session.commit()
meal_name = "katogo"
price = 2000
meal_type = "lunch"
meal = Meals(meal_name=meal_name, price=price, meal_type=meal_type)
db.session.add(meal)
db.session.commit()
details = {"email": "*****@*****.**", "password": "******"}
response = self.app.post("/bookmealapi/v1.0/auth/login",\
data=json.dumps(details), content_type='application/json')
self.assertEqual(response.status_code, 200)
data = json.loads(response.get_data())
token = data['token']
details = {
"meal_name": "rolex",
"price": 8000,
"meal_type": "breakfast"
}
response = self.app.put("/bookmealapi/v1.0/meals/1",\
data=json.dumps(details), content_type='application/json',\
headers={'x-access-token' : token})
self.assertEqual(response.status_code, 201)
data = json.loads(response.get_data())
# self.assertEqual(data['meal']['id'], 2)
self.assertEqual(data['meal']['meal_name'], "rolex")
self.assertEqual(data['meal']['price'], 8000)
self.assertEqual(data['meal']['meal_type'], "breakfast")
def feeddetails(**kwargs):
# app.logger.info(kwargs['email'])
# app.logger.info(request.args.get('feedurl'))
user = User()
print "*** printing request params"
print request.args.get('pageno')
print request.args.get('pagesize')
if request.args.get('pageno') is not None and request.args.get(
'pagesize') is not None:
nobj = user.getfeeddata(db.connection, kwargs['email'],
request.args.get('feedurl'),
request.args.get('pageno'),
request.args.get('pagesize'))
else:
nobj = user.getfeeddata(db.connection, kwargs['email'],
request.args.get('feedurl'))
return buildresponse(nobj, {'http_status': 200})
def post(self):
registerData = {
'username': request.json['username'],
'password': request.json['password'],
'email': request.json['email']
}
if not registerData['username'] or not registerData[
'password'] or not registerData['email']:
return jsonify(message='Missing parameters')
if User.objects(username=registerData['username']).first():
return jsonify(message='This user already exist!')
if User.objects(email=registerData['email']).first():
return jsonify(
message='This email address is already used, please use other')
User(password=bcrypt.generate_password_hash(registerData['password']),
username=registerData['username'],
email=registerData['email']).save()
return jsonify(message='User successful created!')
def test_add_meal_valid(self):
""" correct values """
business_name = "FAST FOOD"
location = "nakulabye"
first_name = "atlas"
last_name = "waters"
email = "*****@*****.**"
password = "******"
role_id = 1
hashed_password = generate_password_hash(password, method='sha256')
new_admin = User(first_name= first_name, last_name=last_name,\
email=email, password= hashed_password, role_id=role_id,\
business_name=business_name, location=location)
db.session.add(new_admin)
db.session.commit()
""" correct details admin """
details = {"email": "*****@*****.**", "password": "******"}
response = self.app.post("/bookmealapi/v1.0/auth/login",\
data=json.dumps(details), content_type='application/json')
data = json.loads(response.get_data())
token = data['token']
details = {
"meal_name": "katogo",
"price": 2000,
"meal_type": "breakfast"
}
response = self.app.post("/bookmealapi/v1.0/meals",\
data=json.dumps(details), content_type='application/json',\
headers={'x-access-token' : token})
self.assertEqual(response.status_code, 201)
data = json.loads(response.get_data())
self.assertEqual(data['message'], "Meal Successfully Added")
#same meal name
details = {
"meal_name": "katogo",
"price": 2000,
"meal_type": "breakfast"
}
response = self.app.post("/bookmealapi/v1.0/meals",\
data=json.dumps(details), content_type='application/json',\
headers={'x-access-token' : token})
self.assertEqual(response.status_code, 400)
def addfeed(**kwargs):
# app.logger.info(kwargs['email'])
# app.logger.info(request.json['feedurl'])
# app.logger.info(request.json['category'])
# app.logger.info(app.config['HTTP_PROXY'])
user = User()
nobj = user.addfeed(db.connection, kwargs['email'],
request.json['feedurl'], request.json['category'],
{'http_proxy': app.config['HTTP_PROXY']})
if not nobj.haserrors and nobj.result is not None:
nobj.result = {}
resobj = user.getfeedtree(db.connection, kwargs['email'])
if not resobj.haserrors:
nobj.result["feedlist"] = resobj.result
resobj = user.getcategorylist(db.connection, kwargs['email'])
if not resobj.haserrors:
nobj.result["categories"] = resobj.result
return buildresponse(nobj, {'http_status': 201})
