def edit_user():
""""""
res = {}
try:
connection = Connection()
reader = readQ(connection)
updater = updateQ(connection)
updater.edit_user()
arr = []
# weight_list = lis.dict()
# for weight in weight_list["weights"]:
# time_gap = client_time - weight["weighing_date"]
# weight_time = "to_timestamp(" + str(server_time - time_gap) + ")"
# if weight["weight_value"] >= 0:
# query = reader.get_container_item_id_query(weight["business_id"], weight["container_id"])
# res = connection.get_result(query)
#
# if len(res) > 0:
# item_id = res[0]["item_id"]
# else:
# raise HTTPException(status_code=404, detail="Container has no item configured for this business")
# arr.insert(0, [weight_time, weight["business_id"], weight["container_id"], item_id,
# weight["weight_value"], weight["last_user"]])
except (Exception):
pass
return res
async def add_container_to_business(business_id: int,
container_id: Optional[int] = None):
"""admin removal of container from all businesses and add to a specific business
if no container_id provided then creates new one.
returns the container id of the container added"""
connection = Connection()
updater = updateQ(connection)
reader = readQ(connection)
have_container_id = container_id is not None
business_query = reader.get_business_query(business_id)
business_info = connection.get_result(business_query)
if not business_info or len(business_info) < 1:
raise HTTPException(status_code=404, detail="Business id not found")
if have_container_id:
remove_query = updater.disable_container_query(container_id)
connection.insert_data(remove_query, "unable to remove container")
addition_query = updater.add_container_to_business_query(
business_id, container_id)
connection.insert_data(addition_query, "unable to add container")
if not have_container_id:
get_container_id = reader.get_new_container()
res = connection.get_result(get_container_id)
if res and len(res) > 0 and res[0] and "container_id" in res[
0] and res[0]["container_id"]:
container_id = res[0]["container_id"]
else:
raise HTTPException(
status_code=500,
detail="error retrieving new container created ")
return container_id
async def pair_container_to_item(business_id: int, container_id: int,
item_id: int):
"""pair a container that belongs to the business provided, to the item that was provided.
removes all previous container pairings"""
connection = Connection()
updater = updateQ(connection)
reader = readQ(connection)
container_query = reader.get_container_by_id_query(container_id)
container_res = connection.get_result(container_query)
try:
container = container_res[0]
if business_id != container["business_id"]:
raise Exception
except Exception:
raise HTTPException(status_code=403,
detail="Container does not belong to business")
item_query = reader.get_items(item_id, business_id)
item_res = connection.get_result(item_query)
if item_res is None or len(item_res) < 1:
raise HTTPException(status_code=403,
detail="Item does not belong to business")
remove_query = updater.disable_container_query(container_id)
connection.insert_data(remove_query, "unable to remove container")
addition_query = updater.add_container_to_business_query(
business_id, container_id, item_id)
connection.insert_data(addition_query, "unable to add container")
async def get_item_history(business_id: int,
item_id: int,
min_date: Optional[int] = -1,
max_date: Optional[int] = -1):
"""gets an items weight history
input: business_id, item_id - ids
max,min dates - Unix Timestamp - represents the time window for the history.
it is required to send one date of reference"""
if min_date <= 0:
min_date = None
if max_date < 0:
max_date = None
if not min_date and not max_date:
raise HTTPException(status_code=404, detail="No date to reference")
connection = Connection()
reading = readQ(connection)
query, res_code = reading.get_weight_history(item_id, business_id,
min_date, max_date)
if res_code != 200:
raise HTTPException(status_code=500,
detail="Unable to create a history query")
print(query)
res = connection.get_result(query)
del connection
return res
async def get_items(business_id: int):
"""get all items of business """
pass
connection = Connection()
reader = readQ(connection)
query = reader.get_items(business_id=business_id)
return connection.get_result(query)
def get_user_preferences(user_email: str):
"""gets preferences for a specific user based on user_email
required parameters: user_email"""
connection = Connection()
reader = readQ(connection)
user_id = reader.get_userid_by_email(user_email)
query = readQ.get_user_preferences_query(user_id)
return connection.get_result(query)
async def add_weights(lis: WeighingList, client_time: int):
"""gets a WeighingList and inserts it in to the database"""
try:
connection = Connection()
reader = readQ(connection)
updater = updateQ(connection)
arr = []
server_time = int(time.time())
weight_list = lis.dict()
data_inserted = {}
for weight in weight_list["weights"]:
time_gap = client_time - weight["weighing_date"]
weight_time = "to_timestamp(" + str(server_time - time_gap) + ")"
if weight["weight_value"] >= 0:
query = reader.get_container_item_id_query(
weight["business_id"], weight["container_id"])
res = connection.get_result(query)
if len(res) > 0:
item_id = res[0]["item_id"]
else:
raise HTTPException(
status_code=404,
detail=
"Container has no item configured for this business")
arr.insert(0, [
weight_time, weight["business_id"], weight["container_id"],
item_id, weight["weight_value"], weight["last_user"]
])
data_inserted[weight["container_id"]] = weight["weight_value"]
await settings.notifications_handler.update_item(
weight["business_id"], item_id, weight["container_id"],
weight["weight_value"], 1, updater)
query, res_code = updater.insert_to_table_query(
"weights", [
"weighing_date", "business_id", "container_id", "item_id",
"weight_value", "last_user"
], arr)
connection.insert_data(query, res_code)
message = "weights updated for: "
for container_id in data_inserted:
message += "container: " + str(container_id) + " weight: " + str(
data_inserted[container_id])
del connection
return message
except HTTPException as error:
raise error
except (Exception, psycopg2.DatabaseError) as error:
print(error)
settings.email_client.email_admin("Unable to add weight",
"error details:" + str(error))
settings.log_manager.log_error(error)
raise HTTPException(status_code=400, detail="unable to add weight")
def __init__(self, connection=False):
if not connection:
connection = Connection()
self.connection = connection
self.reader = readQ(self.connection)
def create_alert_dictionary(self):
"""this function creates an alert dictionary that will look like this
{business id:{
item_id:{
"total_maximum":value,
"total_minimum":value,
"maximum_per_day":value,
"minimum_per_day":value,
"unit":value,
"sum":value,
containers:{
container id :{weight:value, unit:value}
}
}"""
alert_dict = {}
connection = Connection()
try:
reader = readQ(connection)
rules_query = reader.get_rules_query()
rules = connection.get_result(rules_query)
if rules:
for rule in rules:
item_info = {}
if "item_id" in rule and rule[
"item_id"] and "business_id" in rule and rule[
"business_id"]:
business_id = rule["business_id"]
item_id = rule["item_id"]
if "content_minimum_per_day" in rule and rule[
"content_minimum_per_day"]:
item_info["minimum_per_day"] = rule[
"content_minimum_per_day"]
if "content_maximum_per_day" in rule and rule[
"content_maximum_per_day"]:
item_info["maximum_per_day"] = rule[
"content_maximum_per_day"]
if "content_total_minimum" in rule and rule[
"content_total_minimum"]:
item_info["total_minimum"] = rule[
"content_total_minimum"]
if "content_total_maximum" in rule and rule[
"content_total_maximum"]:
item_info["total_maximum"] = rule[
"content_total_maximum"]
if "item_average_weight" in rule and rule[
"item_average_weight"]:
item_info["item_average_weight"] = rule[
"item_average_weight"]
item_info["sum"] = 0
if business_id not in alert_dict:
alert_dict[business_id] = {}
alert_dict[business_id][item_id] = item_info
current_weight_by_container = reader.get_current_weight_query(
get_by_container=True)
containers = connection.get_result(current_weight_by_container)
if containers:
for container in containers:
try:
business_id = container["business_id"]
item_id = container["item_id"]
container_id = container["container_id"]
container_data = {
"weight": container["weight"],
"unit": container["unit"]
}
item_info = alert_dict[business_id][item_id]
if "containers" not in item_info:
item_info["containers"] = {}
item_info["containers"][container_id] = container_data
except KeyError:
pass
notification_list_query = reader.get_notifications()
notifications = connection.get_result(notification_list_query)
if notifications:
for notification in notifications:
try:
business_id = notification["business_id"]
item_id = notification["item_id"]
code = notification["code"]
item_info = alert_dict[business_id][item_id]
item_info["active_notification"] = code
except KeyError:
pass
except (Exception, psycopg2.DatabaseError) as error:
print(error)
self.email_client.email_admin("Error reading notification data",
"error details:" + str(error))
if connection:
del connection
return alert_dict
def __init__(self, connection):
self.connection = connection
self.reader = readQ(self.connection)
self.creator = createQ(self.connection)