def create_item():
db_connection = create_db_connection()
if db_connection:
data = request.get_json()
item_name = data['item_name']
item_cost = float(data['item_cost'])
item_quantity = 1 # data['item_amount'] for now just storing it as one
group_url = data['group_url']
if item_cost <= 0:
response = {"error": "Item cannot be worth a negative amount or 0"}
return response, 400
if len(item_name) == 0:
response = {"error": "Please add a name for this new item"}
return response, 400
# Find the group first
group_object = db_connection.query(Groups).filter(
Groups.groupURL ==
group_url).first() # use first to avoid accessing as array
# We do not care for duplicates
item_exists = db_connection.query(Items).filter(
(Items.itemName == item_name),
(Items.groupID == group_object.groupID)).first()
if item_exists:
response = {"error": "Item already exists"}
db_connection.close()
return response, 400
else:
item_object = Items(itemName=item_name,
itemCost=item_cost,
itemQuantity=item_quantity,
groupID=group_object.groupID)
db_connection.add(item_object)
# update total cost and subtotal
db_connection.query(Groups).filter(
Groups.groupURL == group_url).update({
"subTotal":
group_object.subTotal + item_cost,
"totalCost": (group_object.subTotal + item_cost) *
(1.00875) + ((group_object.subTotal + item_cost) *
group_object.tipRate / 100)
})
db_connection.commit()
db_connection.close()
# returns message saying item created
response = {"message": f"{item_name} successfully created"}
return response, 200
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def create_user():
db_connection = create_db_connection()
if db_connection:
data = request.get_json()
user = data['nickname']
amount_adjusted = float(data['amount_adjusted'])
group_url = data['group_url']
if len(user) == 0:
response = {"error": "Please enter a name"}
return response, 400
# Find the group first
group_object = db_connection.query(Groups).filter(
Groups.groupURL ==
group_url).first() # use first to avoid accessing as array
# Check if nickname already exists
user_exists = db_connection.query(Users).filter(
(Users.nickname == user),
(Users.groupID == group_object.groupID)).first()
if user_exists:
response = {"error": "User already exists"}
db_connection.close()
return response, 400
else:
user_object = Users(nickname=user,
amountOwed=0.0,
adjustedAmount=amount_adjusted,
groupID=group_object.groupID)
db_connection.add(user_object)
db_connection.query(Groups).filter(
Groups.groupURL == group_url).update({
"userCount":
group_object.userCount + 1,
"totalAdjustment":
group_object.totalAdjustment + user_object.adjustedAmount
})
db_connection.commit()
db_connection.close()
# returns message saying item created
response = {"message": f"{user} successfully created"}
return response, 200
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def upload():
db_connection = create_db_connection()
if db_connection:
# Need to move the contents from the request.data to the request.files
request.get_data(parse_form_data=True)
# Now can access the files
data = (request.files['file'])
# convert the randomized value into a string
# give it a random name, cause same file names will replace each other
letters = str(uuid.uuid4())
# Need to use Boto3 to use AWS services
AWS_ACCESS_KEY_ID = os.getenv('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY = os.getenv('AWS_SECRET_ACCESS_KEY')
BUCKET = os.getenv('BUCKET')
# FOLDER = os.getenv('FOLDER')
s3 = boto3.client('s3',
aws_access_key_id=AWS_ACCESS_KEY_ID,
aws_secret_access_key=AWS_SECRET_ACCESS_KEY
) # specifying amazon resource
object_url = None
if data:
try:
# https://boto3.amazonaws.com/v1/documentation/api/latest/guide/s3-uploading-files.html
response = s3.upload_fileobj(
data,
BUCKET,
letters,
ExtraArgs={"ContentType": "image/jpeg"}
) # (our img, name of aws bucket, and object url name would be awsurl+random letter we generated)), returns true or false
object_url = f"https://{BUCKET}.s3.amazonaws.com/{letters}"
except ClientError as e:
logging.error(e)
result = {'error': 'Image Upload Failed'}
return result, 400
db_connection.close()
return {"message": f"{object_url}"}, 200
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def edit_tip_rate():
db_connection = create_db_connection()
if db_connection:
data = request.get_json()
tip_rate = float(data['tip_rate'])
group_url = data['group_url']
# Get the group info
user_session = db_connection.query(Groups).filter(
Groups.groupURL == group_url).first()
if tip_rate != user_session.tipRate:
# NEED TO RECALCULATE PRICES AGAIN
db_connection.query(Groups).filter(
Groups.groupID == user_session.groupID).update({
"tipRate": (tip_rate),
'totalCost': (user_session.subTotal * 1.08875) +
(user_session.subTotal * tip_rate / 100)
})
db_connection.commit()
db_connection.close()
response = {'message': 'Tip Rate updated'}
return response, 200
else:
response = {'message': "Nothing to change"}
return response, 400
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def unassign_item():
db_connection = create_db_connection()
if db_connection:
data = request.get_json()
# gather data
user = data['nickname']
item_name = data['item_name']
group_url = data['group_url']
# query the referenced groups for the caller user
group_object = db_connection.query(Groups).filter(
Groups.groupURL == group_url).first()
user_object = db_connection.query(Users).filter(
(Users.nickname == user),
(Users.groupID == group_object.groupID)).first()
item_object = db_connection.query(Items).filter(
(Items.itemName == item_name),
(Items.groupID == group_object.groupID)).first()
# query data for price calculation
curr_cost_per_person = item_object.itemCostPerPerson
# see item-user pair exists
item_user_exist = db_connection.query(ItemAssignments).filter(
(ItemAssignments.itemID == item_object.itemID),
(ItemAssignments.userID == user_object.userID)).first()
if not item_user_exist:
response = {"error": "Assignment doesn't exist"}
db_connection.close()
return response, 404
else:
# get assignment pair id from itemAssignment table
pair_id = item_user_exist.itemAssignmentID
# delete assignment pair from itemAssignment table
db_connection.query(ItemAssignments).filter(
ItemAssignments.itemAssignmentID == pair_id).delete()
# update current users cost
curr_user_owes = user_object.amountOwed
curr_user_update_owes = curr_user_owes - curr_cost_per_person
# update amountOwed for user calling function
db_connection.query(Users).filter(
Users.userID == user_object.userID).update(
{"amountOwed": curr_user_update_owes})
db_connection.commit()
# -------- UPDATES AMOUNT OWED FOR ALL OTHER USERS ASSOCIATED WITH ITEM --------
# gets new item count and new number of users associated with that item
new_user_count = db_connection.query(ItemAssignments).filter(
(ItemAssignments.itemID == item_object.itemID)).count()
# if user count == 0, treat as if 1 person
if (new_user_count == 0):
new_user_count = 1
item_price = item_object.itemCost
# change price per person on item
new_per_person_price = round(item_price / new_user_count, 2)
# commit new price per person on table Item
db_connection.query(Items).filter(
Items.itemID == item_object.itemID).update(
{"itemCostPerPerson": new_per_person_price})
db_connection.commit()
# update amount owed for all users associated with item
item_assignment_object = db_connection.query(
ItemAssignments).filter(
ItemAssignments.itemID == item_object.itemID)
# traverse through each assignment pair
for assignments in item_assignment_object:
# get user of assignment pair being looked at
curr_pair_user = db_connection.query(Users).filter(
Users.userID == assignments.userID).first()
if (item_assignment_object.count() > 0):
# updates users current price owed
user_total = curr_pair_user.amountOwed - curr_cost_per_person + new_per_person_price
db_connection.query(Users).filter(
Users.userID == assignments.userID).update(
{"amountOwed": user_total})
db_connection.commit()
db_connection.close()
# returns message saying item created
response = {
"message": f"{user} and {item_name} unpaired successfully"
}
return response, 200
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def delete_user():
db_connection = create_db_connection()
if db_connection:
data = request.get_json()
user_nickname = data['nickname']
group_url = data['group_url']
# Find the group first
group_object = db_connection.query(Groups).filter(Groups.groupURL == group_url).first() # use first to avoid accessing as array
# Find the item object
user_object = db_connection.query(Users).filter((Users.nickname == user_nickname),(Users.groupID == group_object.groupID)).first()
user_id = user_object.userID
# Check if user doesn't exist
if user_object is None:
response = {"error": "User does not exists"}
db_connection.close()
return response, 404
# get all item-user assignments associated with this item
item_assignment_object = db_connection.query(ItemAssignments).filter(ItemAssignments.userID == user_object.userID)
db_connection.query(Groups).filter(Groups.groupID == group_object.groupID).update({
"userCount": group_object.userCount - 1,
"totalAdjustment": (group_object.totalAdjustment - user_object.adjustedAmount)
})
db_connection.commit()
# delete user if user is not assigned to any item
if item_assignment_object.count() ==0:
db_connection.query(Users).filter(Users.userID == user_id).delete()
db_connection.commit()
response = {"message": f"{user_nickname} successfully deleted"}
return response, 200
else:
# loop through all items associated with user
for user_pair in item_assignment_object:
# retrieve information about currently indexed item
curr_item = db_connection.query(Items).filter(Items.itemID == user_pair.itemID).first()
# get current cost per person on item
old_item_cost_per_person = curr_item.itemCostPerPerson
# delete specific user-item assignment pair
db_connection.query(ItemAssignments).filter(ItemAssignments.itemAssignmentID == user_pair.itemAssignmentID).delete()
# gets new item count and new number of users associated with that item
new_user_count = db_connection.query(ItemAssignments).filter((ItemAssignments.itemID == curr_item.itemID)).count()
# if user count == 0, treat as if 1 person
if(new_user_count == 0):
new_user_count = 1
item_price = curr_item.itemCost
# change price per person on item
new_per_person_price = round(item_price/new_user_count, 2)
# commit new price per person on table Item
db_connection.query(Items).filter(Items.itemID == curr_item.itemID).update({"itemCostPerPerson": new_per_person_price})
db_connection.commit()
# retrieve remaining users paired with current item
remaining_paired_users = db_connection.query(ItemAssignments).filter(ItemAssignments.itemID == curr_item.itemID)
for pair in remaining_paired_users:
# get user of assignment pair being looked at
curr_pair_user = db_connection.query(Users).filter(Users.userID == pair.userID).first()
if(remaining_paired_users.count() > 0):
user_total = curr_pair_user.amountOwed - old_item_cost_per_person + new_per_person_price
db_connection.query(Users).filter(Users.userID == pair.userID).update({"amountOwed": user_total})
db_connection.commit()
db_connection.query(Users).filter(Users.userID == user_id).delete()
db_connection.commit()
response = {"message": f"{user_nickname} successfully deleted"}
return response, 200
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def delete_item():
db_connection = create_db_connection()
if db_connection:
data = request.get_json()
item_name = data['item_name']
group_url = data['group_url']
# Find the group first
group_object = db_connection.query(Groups).filter(Groups.groupURL == group_url).first() # use first to avoid accessing as array
# Find the item object
item_object = db_connection.query(Items).filter((Items.itemName == item_name), (Items.groupID == group_object.groupID)).first()
item_id = item_object.itemID
# Check if item doesn't exist
if item_object is None:
response = {"error": "Item does not exists"}
db_connection.close()
return response, 404
db_connection.query(Groups).filter(Groups.groupURL == group_url).update({
"subTotal": group_object.subTotal - item_object.itemCost,
"totalCost": (group_object.subTotal - item_object.itemCost)*(1.00875)+ ((group_object.subTotal - item_object.itemCost) * group_object.tipRate/100)
})
db_connection.commit()
item_cost_per_person = item_object.itemCostPerPerson
# get all item-user assignments associated with this item
item_assignment_object = db_connection.query(ItemAssignments).filter(ItemAssignments.itemID == item_object.itemID)
# delete item if item is not assigned to any users
if item_assignment_object is None:
db_connection.query(Items).filter(Items.itemID == item_id).delete()
db_connection.commit()
response = {"message": f"{item_name} successfully deleted"}
return response, 200
else:
for assignments in item_assignment_object:
# get user of assignment pair being looked at
curr_pair_user = db_connection.query(Users).filter(Users.userID == assignments.userID).first()
# recalculate user total
user_total = curr_pair_user.amountOwed - item_cost_per_person
# update total
db_connection.query(Users).filter(Users.userID == assignments.userID).update({"amountOwed": user_total})
db_connection.commit()
# delete assignment pair from db
db_connection.query(ItemAssignments).filter(ItemAssignments.itemAssignmentID == assignments.itemAssignmentID).delete()
db_connection.commit()
db_connection.query(Items).filter(Items.itemID == item_id).delete()
db_connection.commit()
response = {"message": f"{item_name} successfully deleted"}
return response, 200
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def edit_item():
db_connection = create_db_connection()
if db_connection:
data = request.get_json()
item_name = data['item_name']
new_item_name = data['new_item_name']
new_item_cost = float(data['new_item_cost'])
group_url = data['group_url']
# Find the group first
group_object = db_connection.query(Groups).filter(
Groups.groupURL ==
group_url).first() # use first to avoid accessing as array
# Find the item object
item_object = db_connection.query(Items).filter(
(Items.itemName == item_name),
(Items.groupID == group_object.groupID)).first()
# Check if item doesn't exist
if item_object is None:
response = {"error": "Item does not exists"}
db_connection.close()
return response, 404
if len(new_item_name) and (new_item_name != item_name):
# Check if item with new name already exists
new_item_exist = db_connection.query(Items).filter(
(Items.itemName == new_item_name),
(Items.groupID == group_object.groupID)).first()
if new_item_exist:
response = {
"error":
"Invalid. An item with "
f"{new_item_name} already exists."
}
db_connection.close()
return response, 400
# update item's name
db_connection.query(Items).filter(
Items.itemID == item_object.itemID).update(
{"itemName": new_item_name})
db_connection.commit()
# Get item current cost
old_item_cost = item_object.itemCost
# Get current cost per person
old_item_cost_per_person = item_object.itemCostPerPerson
if (new_item_cost != old_item_cost):
# Get number of users associated with item
user_count = db_connection.query(ItemAssignments).filter(
(ItemAssignments.itemID == item_object.itemID)).count()
# new cost per person
if (user_count > 0):
new_cost_per_person = round(new_item_cost / user_count, 2)
else:
new_cost_per_person = new_item_cost
# get all item-user assignments associated with this item
item_assignment_object = db_connection.query(
ItemAssignments).filter(
ItemAssignments.itemID == item_object.itemID)
# update item's base cost
db_connection.query(Items).filter(
Items.itemID == item_object.itemID).update(
{"itemCost": new_item_cost})
db_connection.commit()
# calculate new subtotal
new_subtotal = group_object.subTotal - old_item_cost + new_item_cost
# update total cost and subtotal
db_connection.query(Groups).filter(
Groups.groupURL == group_url).update({
"subTotal":
new_subtotal,
"totalCost": (new_subtotal) * (1.00875) +
((new_subtotal) * group_object.tipRate / 100)
})
db_connection.commit()
# update item's cost per person
db_connection.query(Items).filter(
Items.itemID == item_object.itemID).update(
{"itemCostPerPerson": new_cost_per_person})
db_connection.commit()
# traverse through each assignment pair
for assignments in item_assignment_object:
# get user of assignment pair being looked at
curr_pair_user = db_connection.query(Users).filter(
Users.userID == assignments.userID).first()
if (item_assignment_object.count() > 0):
# updates users current price owed
user_total = curr_pair_user.amountOwed - old_item_cost_per_person + new_cost_per_person
db_connection.query(Users).filter(
Users.userID == assignments.userID).update(
{"amountOwed": user_total})
db_connection.commit()
db_connection.close()
response = {"message": f"{item_name} successfully updated"}
return response, 200
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def reupload():
db_connection = create_db_connection()
if db_connection:
group_url = request.args['group_URL']
# Need to move the contents from the request.data to the request.files
request.get_data(parse_form_data=True)
# Now can access the files
data = request.files['file']
# Need to get image url from group_url in order to delete it in S3
group_object = db_connection.query(Groups).filter(
Groups.groupURL == group_url).first()
image_to_delete = group_object.imageURL
# Need to use Boto3 to use AWS services
AWS_ACCESS_KEY_ID = os.getenv('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY = os.getenv('AWS_SECRET_ACCESS_KEY')
BUCKET = os.getenv('BUCKET')
s3 = boto3.client('s3',
aws_access_key_id=AWS_ACCESS_KEY_ID,
aws_secret_access_key=AWS_SECRET_ACCESS_KEY
) # specifying amazon resource
# Delete the image if we have one ––––––––––––––––––––––––––––––––––––-
if (len(image_to_delete) != 0):
index = image_to_delete.rfind('/') + 1
image_to_delete_key = image_to_delete[index:]
# https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3.html#S3.Object
try:
response = s3.delete_object(Bucket=BUCKET,
Key=image_to_delete_key)
except ClientError as e:
logging.error(e)
result = {'error': 'Image Deletion Failed'}
return result, 400
# Update User Expensis to 0 –––––––––––––––––––––––––––––––––––––––––––
users_object = db_connection.query(Users).filter(
Users.groupID ==
group_object.groupID) # should get an array of users
for user in users_object:
db_connection.query(Users).filter(
Users.userID == user.userID).update({
"amountOwed": 0,
})
db_connection.commit()
# Delete all items and item assignments –––––––––––––––––––––––––––––––
items_object = db_connection.query(Items).filter(
Items.groupID == group_object.groupID)
for item in items_object:
item_id = item.itemID
# get all item-user assignments associated with this item
item_assignment_object = db_connection.query(
ItemAssignments).filter(ItemAssignments.itemID == item_id)
# if there assignments we will delete them
if item_assignment_object is not None:
for assignments in item_assignment_object:
# delete assignment pair from db
db_connection.query(ItemAssignments).filter(
ItemAssignments.itemAssignmentID ==
assignments.itemAssignmentID).delete()
db_connection.commit()
db_connection.query(Items).filter(Items.itemID == item_id).delete()
db_connection.commit()
# New Image Upload –––––––––––––––––––––––––––––––––––––––––––––––––––
# Convert the randomized value into a string
# Give it a random name, cause same file names will replace each other
letters = str(uuid.uuid4())
object_url = None
if data:
try:
# https://boto3.amazonaws.com/v1/documentation/api/latest/guide/s3-uploading-files.html
response = s3.upload_fileobj(
data,
BUCKET,
letters,
ExtraArgs={"ContentType": "image/jpeg"}
) # (our img, name of aws bucket, and object url name would be awsurl+random letter we generated), returns true or false
object_url = f"https://{BUCKET}.s3.amazonaws.com/{letters}"
except ClientError as e:
logging.error(e)
result = {'error': 'Image Upload Failed'}
return result, 400
# Reprocess all the data –––––––––––––––––––––––––––––––––––––––––––––
items_list = None
# if we have an image to work with we need to process it
if (len(object_url) > 0):
index = object_url.rfind('/') + 1
name = object_url[index:]
BUCKET = os.getenv('BUCKET')
REGION = os.getenv('REGION')
s3cli = boto3.resource('s3', region_name=REGION)
bucket = s3cli.Bucket(BUCKET)
object = bucket.Object(name)
tmp = tempfile.NamedTemporaryFile()
with open(tmp.name, 'wb') as f:
object.download_fileobj(f)
items_list = imageToJson(tmp.name)
items_total = 0
if items_list:
for item in items_list:
item_object = Items(itemName=item['name'],
itemCost=item['price'],
itemQuantity=1,
itemCostPerPerson=item['price'],
groupID=group_object.groupID)
db_connection.add(item_object)
items_total += item['price']
db_connection.query(Groups).filter(
Groups.groupURL == group_object.groupURL).update({
"imageURL":
object_url,
"subTotal":
items_total,
"totalCost": (items_total) * (1.00875) +
(items_total * group_object.tipRate / 100)
})
db_connection.commit()
response = {"message": "Successfully Reuploaded Image"}
return response, 200
# Assume on front end we call get group again after we reset everything
else:
result = {'error': 'Connection to Datavase Failed'}
return result, 400
db_connection.close()
def assign_item():
db_connection = create_db_connection()
if db_connection:
data = request.get_json()
# gather data
user = data['nickname']
item_name = data['item_name']
group_url = data['group_url']
# query the referenced groups for the caller user
group_object = db_connection.query(Groups).filter(
Groups.groupURL == group_url).first()
user_object = db_connection.query(Users).filter(
(Users.nickname == user),
(Users.groupID == group_object.groupID)).first()
item_object = db_connection.query(Items).filter(
(Items.itemName == item_name),
(Items.groupID == group_object.groupID)).first()
if (user_object is None):
response = {"error": "This user doesn't exist"}
return response, 400
# query data for price calculation
curr_cost_per_person = item_object.itemCostPerPerson
# see item-user pair exists
item_user_exist = db_connection.query(ItemAssignments).filter(
(ItemAssignments.itemID == item_object.itemID),
(ItemAssignments.userID == user_object.userID)).first()
if item_user_exist:
response = {"error": "Item & User already assigned"}
db_connection.close()
return response, 400
else:
# calculate the new price per person when we add this new person
new_user_count = db_connection.query(ItemAssignments).filter(
(ItemAssignments.itemID == item_object.itemID)).count() + 1
item_price = item_object.itemCost
new_cost_per_person = round(item_price / new_user_count, 2)
# update Items with the new cost per person
db_connection.query(Items).filter(
Items.itemID == item_object.itemID).update(
{"itemCostPerPerson": new_cost_per_person})
# update amount owed for current users associated with item
item_assignment_object = db_connection.query(
ItemAssignments).filter(
ItemAssignments.itemID == item_object.itemID)
# traverse through each assignment pair
for assignments in item_assignment_object:
# get user of assignment pair being looked at
curr_pair_user = db_connection.query(Users).filter(
Users.userID == assignments.userID).first()
# calculates currently assigned user by subtracting previous cost_per_person with new_cost_per_person
user_total = curr_pair_user.amountOwed - curr_cost_per_person + new_cost_per_person
db_connection.query(Users).filter(
Users.userID == assignments.userID).update(
{"amountOwed": user_total})
db_connection.commit()
# calculate desired new user's amountOwed
curr_user_owes = user_object.amountOwed
curr_user_update_owes = curr_user_owes + new_cost_per_person
# update amountOwed for user in db
db_connection.query(Users).filter(
Users.userID == user_object.userID).update(
{"amountOwed": curr_user_update_owes})
db_connection.commit()
# create and commit pair to db
pair_object = ItemAssignments(userID=user_object.userID,
itemID=item_object.itemID)
db_connection.add(pair_object)
db_connection.commit()
db_connection.close()
# returns message saying item created
response = {
"message": f"{user} and {item_name} paired successfully"
}
return response, 200
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def edit_user():
db_connection = create_db_connection()
if db_connection:
data = request.get_json()
nickname = data['nickname']
new_nickname = data['new_nickname']
adjusted_amount = float(data['adjusted_amount'])
group_url = data['group_url']
# Find the group first
group_object = db_connection.query(Groups).filter(
Groups.groupURL ==
group_url).first() # use first to avoid accessing as array
# Fetch the user
user_exists = db_connection.query(Users).filter(
(Users.nickname == nickname),
(Users.groupID == group_object.groupID)).first()
if user_exists is None:
response = {"error": "User doesn't exist"}
return response, 400
if len(new_nickname) and (new_nickname != nickname):
# Check if nickname already exists
new_user_exists = db_connection.query(Users).filter(
(Users.nickname == new_nickname),
(Users.groupID == group_object.groupID)).first()
if new_user_exists:
response = {
"error": "Invalid, a user with new_nickname already exists"
}
db_connection.close()
return response, 400
# update works on array of data or bulk data not single entity apprently
db_connection.query(Users).filter(
Users.userID == user_exists.userID
).update(
{
"nickname": new_nickname,
}
) # https://docs.sqlalchemy.org/en/13/orm/query.html#sqlalchemy.orm.query.Query.update
if adjusted_amount != user_exists.adjustedAmount:
db_connection.query(Groups).filter(
Groups.groupID == group_object.groupID).update({
"totalAdjustment":
(group_object.totalAdjustment -
user_exists.adjustedAmount + adjusted_amount)
})
db_connection.query(Users).filter(
Users.userID == user_exists.userID).update(
{"adjustedAmount": adjusted_amount})
db_connection.commit()
db_connection.close()
# returns message saying item created
response = {"message": f"{nickname} successfully updated"}
return response, 200
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def get_group():
# print(group)
db_connection = create_db_connection()
if db_connection:
url = request.args['group_URL']
if(len(url) == 0):
response = {'error': 'Please Enter a URL'}
return response, 404
# try to find URL in database
user_session = db_connection.query(Groups).filter(Groups.groupURL == url).first()
if user_session is None:
response = {"error": "URL doesn't exist"}
return response, 400
# check if link is expired
if (datetime.datetime.now() > user_session.linkExpiration):
response = {'error': 'URL Has Expired'}
return response, 403
response = {
# 'groupID': user_session.groupID,
'group_url': user_session.groupURL,
# 'locationID': user_session.locationID,
'image_url': user_session.imageURL,
'tip_rate': user_session.tipRate,
'sub_total': user_session.subTotal,
'total_cost': user_session.totalCost,
'tax_rate': 1.08875,
# 'linkExpiration': user_session.linkExpiration,
'user_count': user_session.userCount,
'total_adjustment': user_session.totalAdjustment
}
# need to get location information
location_object = db_connection.query(Locations).filter(Locations.locationID == user_session.locationID).first()
response['location_name'] = location_object.locationName
response['street_address'] = location_object.streetAddress
response['city'] = location_object.city
# zip info
zip_object = None
if location_object:
zip_object = db_connection.query(Zips).filter(Zips.zipID == location_object.zipID).first()
response['zip_code'] = zip_object.zipCode
else:
response['zip_code'] = -1
response['state_name'] = 'NY'
# need to find all users by groupid, find all items they are paired to, and each individual expenses
# get all users
users = db_connection.query(Users).filter(Users.groupID == user_session.groupID).order_by(Users.userID)
total_users = []
user_assignments = {}
for user in users:
user_object = {
'user_nickname': user.nickname,
'user_amount_owed': user.amountOwed,
'user_adjusted_amount': user.adjustedAmount
}
total_users.append(user_object)
user_assignments[user.nickname] = []
# get all items
items = db_connection.query(Items).filter(Items.groupID == user_session.groupID).order_by(Items.itemID)
total_items = []
items_assignments = {}
for item in items:
item_object = {
'item_name': item.itemName,
'item_cost': item.itemCost
}
total_items.append(item_object)
# i_a = {item.itemName: []}
# items_assignments.append(i_a)
items_assignments[item.itemName] = []
# get all item assignments
for item in items_assignments:
# first get item name from your assignments array
# item_name = list(item.keys())[0] # has only one key always
item_name = item
# then use item name to get item object to get id
item_object = db_connection.query(Items).filter((Items.groupID == user_session.groupID),(Items.itemName == item_name)).first()
item_id = item_object.itemID
# use id to get an array of item assignments for that specific item to all the users connected to it
i_a = db_connection.query(ItemAssignments).filter(ItemAssignments.itemID == item_id)
# get user id now to get the name of the person and append it to the value of our dictionary items_assignments
for assignment in i_a:
user_name = db_connection.query(Users).filter(Users.userID == assignment.userID).first()
# item[item_name].append(user_name)
items_assignments[item].append(user_name.nickname)
# get user assignments
for user_nickname in user_assignments:
#get user object to get user id to traverse through assignments
user_object = db_connection.query(Users).filter((Users.groupID == user_session.groupID), (Users.nickname == user_nickname)).first()
user_id = user_object.userID
#use id to get an array of items assignments for this specific user
u_a = list(db_connection.query(ItemAssignments).filter(ItemAssignments.userID == user_id))
#get item id to get the name of the item and append it to the value of our dicitonary user_assignments
for assignment in u_a:
item_name = db_connection.query(Items).filter(Items.itemID == assignment.itemID).first()
user_assignments[user_nickname].append(item_name.itemName)
db_connection.commit()
response['users'] = total_users
response['items'] = total_items
response['item_assignments'] = items_assignments
response['user_assignments'] = user_assignments
db_connection.close()
return response, 200
# Now return all the necessary data
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
def create_group():
db_connection = create_db_connection()
if db_connection:
data = request.get_json()
# gather data
users = data['users']
street_address = data['street_address']
# state_location = data['state']
city_location = data['city']
location_name = data['location_name']
# zip_code = data['zip_code']
zip_code = "10065"
image_s3url = data['image_s3url']
# image_s3url = "https://testblitztest.s3.amazonaws.com/0c193734-6fea-4328-b44f-a570f889da26"
tip_rate = float(data['tip_rate'])
# items_list = data['items']
items_list = None
# if we have an image to work with we need to process it
if (len(image_s3url) > 0):
index = image_s3url.rfind('/') + 1
name = image_s3url[index:]
BUCKET = os.getenv('BUCKET')
REGION = os.getenv('REGION')
s3cli = boto3.resource('s3', region_name=REGION)
# bucketname = 'testblitztest'
# file_to_read = 'unknown2.png'
bucket = s3cli.Bucket(BUCKET)
object = bucket.Object(name)
# object = s3cli.Bucket('testblitztest').Object('unknown.png')
# fileobj = s3cli.get_object(Bucket = bucketname, Key = file_to_read)
tmp = tempfile.NamedTemporaryFile()
with open(tmp.name, 'wb') as f:
object.download_fileobj(f)
items_list = imageToJson(tmp.name)
# location_zip_obj = ["zipID": -1] # -1 will link the zip to state to 2 it to a state called "NOTHING"
# if(len(zip_code) > 0):
# Need to insert data with respect to foreign keys, so location is first so group can use location as FK, then Group is done so user and items can use group as FK, and user and item can be done in any order
# create location object to insert into database
if (len(street_address) == 0):
response = {"error": "Please enter a valid address"}
return response, 400
if (len(location_name) == 0):
response = {"error": "Please enter a location name"}
return response, 400
if (len(users) == 0):
response = {"error": "Please enter at least one user"}
return response, 400
# location is mandatory
location_zip_obj = db_connection.query(Zips).filter(
Zips.zipCode == str(
zip_code)) # returns an array of results, but it is size 1
location_object = Locations(streetAddress=street_address,
city=city_location,
zipID=location_zip_obj[0].zipID,
locationName=location_name)
db_connection.add(location_object)
db_connection.commit() # need to commit first in order to have ID
# once stored location can do Group creation next
# need random link in response
letters = ''.join(
random.choice(string.ascii_letters) for i in range(26))
digits = ''.join(random.choice(string.digits) for i in range(10))
result_string = "/split_bill/" + letters + '_' + digits
frontend_return = "/split_bill/" + letters + '_' + digits
group_object = Groups(groupURL=result_string,
locationID=location_object.locationID,
imageURL=image_s3url,
tipRate=tip_rate,
subTotal=0.0,
totalCost=0.0,
linkExpiration=(datetime.datetime.now() +
datetime.timedelta(days=30)),
userCount=len(users),
totalAdjustment=0.0,
isDeleted=False)
db_connection.add(group_object)
db_connection.commit(
) # need to commit first so it has id before we se in items and users table
for user in users:
user_object = Users(nickname=user,
amountOwed=0.0,
adjustedAmount=0.0,
groupID=group_object.groupID)
db_connection.add(user_object)
items_total = 0
if items_list:
for item in items_list:
item_object = Items(itemName=item['name'],
itemCost=item['price'],
itemQuantity=1,
itemCostPerPerson=item['price'],
groupID=group_object.groupID)
db_connection.add(item_object)
items_total += item['price']
db_connection.query(Groups).filter(
Groups.groupURL == result_string).update({
"subTotal":
items_total,
"totalCost": (items_total) * (1.00875) +
(items_total * group_object.tipRate / 100)
})
db_connection.commit()
response = {
'link': frontend_return,
'message': "Successfully Created Group"
}
db_connection.close()
return response, 200
else:
result = {'error': 'Connection to Database Failed'}
return result, 400
db_connection.close()
