def create_reservation_api(id, id_owner, id_domain, id_element) -> str:
body = request.json
session = Session()
service = get_service(session, id)
owner = get_owner(session, id_owner)
domain = get_domain(session, id_domain)
element = get_element(session, id_element)
client = get_client(session, body["id_client"])
if (element is not None) and (element.reserved == True):
session.close()
return "RESERVED"
if (service is not None) and (owner is not None) and (domain is not None)\
and (owner in service.owner) and (domain in owner.domain)\
and (client is not None) and (element in domain.element)\
and (client in service.client) and (element.reserved ==False):
reservation = create_reservation(session, service, client, element,
body["name"], body["information"],
None, datetime.datetime.now())
reservation.url = "/service/%d/client/%d/reservation/%d" % (
service.id, client.id, reservation.id)
session.commit()
response = reservation.get_dict()
session.close()
return json.dumps(response)
session.close()
return "ERROR"
def get_user_status(username):
session = Session()
user_info = session.query(User).filter(User.name == username).all()
if user_info != []:
session.close()
return user_info[0].state
else:
return None
def insert_user(username, state):
session = Session()
user = User(username, state)
res = session.query(User).filter(User.name == username).all()
if len(res) < 1:
session.add(user)
session.commit()
session.close()
else:
print('User already exists')
def create_element_api(id, id_owner, id_domain) -> str:
body = request.json
session = Session()
service = get_service(session, id)
owner = get_owner(session, id_owner)
domain = get_domain(session, id_domain)
if (service is not None) and (owner is not None) and (domain is not None)\
and (owner in service.owner) and (domain in owner.domain):
element = create_element(session, domain, body["name"],
body["information"], None,
datetime.datetime.now(), body["init_time"],
body["end_time"], body["price"])
element.url = "/service/%d/owner/%d/domain/%d/element/%d" % (
service.id, owner.id, domain.id, element.id)
element.reserved = False
session.commit()
response = element.get_dict()
session.close()
return json.dumps(response)
session.close()
return "ERROR"
def create_review_api():
session = Session()
user_id = request.args.get('usr_id')
body = request.json
if usr_exists(session, user_id) and\
set(["rating", "reviewText", "reviewdObjectID"]).issubset(set(body.keys())):
usr = get_usr_by_idauth(session, user_id)
usr_to = get_usr_from_mail(session, body["reviewdObjectID"])
review = None
if usr_to is None or not review_to_usr_exist(session, usr, usr_to.id):
session.close()
return "ERROR"
if not "reviewID" in body.keys():
review = get_review_by_usrs(session, usr, usr_to.id)
else:
review = get_review(session, body["reviewID"])
if review is not None and\
review_detail_exist(session, usr, usr_to, review.id):
body["authorID"] = usr.mail
r = requests.post(URL_REVIEW + "review", json=body)
delete_review(session, id=review.id)
session.close()
return "OK"
session.close()
return "ERROR"
def genera_risposte(nome_comando, chat_id, bot, list_args):
session = Session()
db_bot = session.query(Bot).filter_by(token=bot._token).first()
comando = db_bot.get_command(nome_comando)
if comando.get_tipo() == 'TEXT':
comando_txt = session.query(Testuali).get(comando.id)
if comando_txt.controllo_args(list_args):
risposta = comando_txt.risposta.format(*list_args)
bot.sendMessage(chat_id, risposta)
else:
bot.sendMessage(chat_id, comando.help_msg)
elif comando.get_tipo() == 'API':
comando_api = session.query(Api).get(comando.id)
_APIS[comando_api.funzione](bot, list_args, chat_id)
else:
pass
def authorization(cls, username: str, password: str):
account = Session.query(cls).filter(User.username == username).first()
if not account:
logging.debug("Account not found")
return None
if not bcrypt.checkpw(password.encode(), account.password.encode()):
logging.debug("Account password mismatch")
return None
return account
def decorated(*args, **kwargs):
auth = request.authorization
if not auth or not check_auth(auth.username, auth.password):
return Response(
"Authentication required.",
401,
)
user = Session.query(User).filter(
User.username == auth.username).first()
request.user_id = user.id
return func(*args, **kwargs)
def list_my_reservations_api():
session = Session()
user_id = request.args.get('usr_id')
if usr_exists(session, user_id):
user = get_usr_by_idauth(session, user_id)
url = URL_RESERVATION + str(BOOKING_SERVICE_ID) + "/client/" + str(
user.id_client_booking) + "/reservation"
r = requests.get(url)
r_list = r.json()
response = list()
for e in r_list:
trip = get_trip_by_domainid(session, e["id_domain"])
if trip is not None:
elem = dict()
event = get_event(session, trip.id_event)
driver = get_usr(session, trip.id_user)
elem['event'] = event.get_dict()
elem['driver'] = driver.get_dict_profile()
elem['trip'] = e
response.append(elem)
session.close()
return jsonify(response)
session.close()
return "ERROR"
def get_my_trips_api():
session = Session()
user_id = request.args.get('usr_id')
if usr_exists(session, user_id):
response = list()
usr = get_usr_by_idauth(session, user_id)
trips = get_usr_trips(session, usr.id)
for t in trips:
tmp = t.get_dict()
event = get_event(session, t.id_event)
tmp['eventName'] = event.name
tmp['eventImg'] = event.image_url
r = requests.get(URL_TRIP_FOLLOWER + "get_trip",
params={"TripId": t.id_iptf})
r = r.json()
tmp["trip"] = r
response.append(tmp)
session.close()
return jsonify(response)
session.close()
return "ERROR"
def create_client_api(id)->str:
body = request.json
session = Session()
service = get_service(session, id)
if service is not None:
client = create_client(session, service, body['name'], body['information'],None,datetime.datetime.now())
client.url="/service/%d/client/%d" % (service.id,client.id)
session.commit()
response = client.get_dict()
session.close()
return json.dumps(response)
session.close()
return "ERROR"
def make_event() -> str:
body = request.json
session = Session()
if set([
"Name", "Description", "Category", "ImageUrl", "City", "SubCity",
"Lat", "Lon", "Date"
]).issubset(set(body.keys())):
event = create_event(session,
body["Name"],
body["Description"],
body["Category"],
body["ImageUrl"],
body["City"],
body["Lat"],
body["Lon"],
body["Date"],
sub_city=body["SubCity"])
response = event.get_dict()
session.close()
return json.dumps(response)
session.close()
return "ERROR"
def get_usr_profile_api():
usr_mail = request.args.get('usr_mail')
session = Session()
usr = get_usr_from_mail(session, usr_mail)
if usr is not None:
response = usr.get_dict_profile()
r = requests.get(URL_REVIEW + "review",
params={'reviewdObjectID': usr.mail})
r = r.json()
for e in r:
mail = e['authorID']
tmp_usr = get_usr_from_mail(session, mail)
if tmp_usr is not None:
e['img_url'] = tmp_usr.img_url
e['name'] = tmp_usr.name
e['mail'] = tmp_usr.mail
response["reviews"] = r
r = requests.get(URL_REVIEW + "avgRating/" + usr.mail)
r = r.json()
if "avgRating" in r.keys():
response["avgRating"] = r["avgRating"]
else:
response["avgRating"] = 0
session.close()
return jsonify(response)
session.close()
return "ERROR"
def get_events() -> str:
event_name = request.args.get('name')
event_city = request.args.get('city')
event_category = request.args.get('category')
events = None
session = Session()
if event_name is not None:
events = get_event_by_name(session, event_name)
if event_city is not None:
e = get_event_by_city(session, event_city)
events = e if events is None else list(set(e) & set(events))
if event_category is not None:
e = get_event_by_category(session, event_category)
events = e if events is None else list(set(e) & set(events))
session.close()
return repr(events) if events is not None else repr(lst())
def create_owner_api(id) -> str:
body = request.json
session = Session()
service = get_service(session, id)
if service is not None:
owner = create_owner(session, service,
body['name'], body['information'], None,
datetime.datetime.now())
owner.url = "/service/%d/owner/%d" % (service.id, owner.id)
session.commit()
response = owner.get_dict()
session.close()
return json.dumps(response)
session.close()
return "ERROR"
def book_trip()->str:
user_id = request.args.get('usr_id')
body = request.json
session = Session()
if set(["EventID","StartTime", "City", "StartCoords","Consumption","AvoidTolls",
"MaxDetour","FuelType", "name", "information", "Price",
"NumSeats"]).issubset(set(body.keys())) and\
usr_exists(session, user_id) and\
event_exist(session, body["EventID"]):
event = get_event(session, body["EventID"])
body["EndCoords"] = [event.lat, event.lon]
body["StartTime"] += event.date
r = requests.post(URL_TRIP_FOLLOWER + "register_trip", json=body)
id_iptf = r.json()
user = get_usr_by_idauth(session, user_id)
owner_id = user.id_owner_booking
url = URL_RESERVATION + str(BOOKING_SERVICE_ID) +"/owner/"+str(owner_id)+"/domain"
d_json = {"name": body["name"], "information": body["information"]}
r = requests.post(url, json=d_json)
id_domain_booking = r.json()['id']
url = URL_RESERVATION + str(BOOKING_SERVICE_ID) + "/owner/" +\
str(owner_id) +"/domain/" + str(id_domain_booking) + "/element"
elem_bdy = {
"name" : body["name"] + "_elem",
"information" : body["information"],
"init_time" : body["StartTime"],
#"init_time" : event.date + body["StartTime"],
#"init_time" : event.date - body["StartTime"],
"end_time" : event.date,
"price" : body["Price"]+2.9
}
if 'NumSeats' in set(body.keys()):
for i in range(0,body['NumSeats']):
elem_bdy["name"] = body["name"] + "_elem" + str(i)
r = requests.post(url, json=elem_bdy)
else:
r = requests.post(url, json=elem_bdy)
trip = create_trip(session, id_domain_booking, id_iptf, body["City"], True, user, event)
response = trip.get_dict()
session.close()
return json.dumps(response)
session.close()
return "ERROR"
def find_event() -> str:
session = Session()
event_id = request.args.get('event_id')
if event_exist(session, event_id):
event = get_event(session, event_id)
response = event.get_dict()
session.close()
return json.dumps(response)
session.close()
return "ERROR"
def get_service_api(id):
session = Session()
service = get_service(session, id)
if service is not None:
response = get_json_service(service)
session.close()
return response
session.close()
return "ERROR"
def remove_event() -> str:
event_id = request.args.get('event_id')
session = Session()
if event_exist(session, event_id):
delete_event(session, id=event_id)
session.close()
return "DELETED"
session.close()
return "ERROR"
def get_aval_seats():
trip_id = request.args.get('trip_id')
session = Session()
if trip_exists_id(session, trip_id):
trip = get_trip(session, trip_id)
if trip.available:
r = requests.get(URL_RESERVATION + str(BOOKING_SERVICE_ID) + "/domain/" +\
str(trip.id_domain_booking) + "/get_aval_elems")
r = r.json()
session.close()
return jsonify(r)
session.close()
return jsonify(list())
session.close()
return "ERROR"
def create_service_api() -> str:
session = Session()
body = request.json
service = create_service(session, body['name'], body['information'], None,
datetime.datetime.now())
service.url = "/service/%d" % (service.id)
session.commit()
response = service.get_dict()
session.close()
return json.dumps(response)
def get_aval_elems(id, id_domain):
session = Session()
service = get_service(session, id)
domain = get_domain(session, id_domain)
if (service is not None) and (domain is not None):
elements = get_domain_aval_elements_w_info(session, domain=domain)
session.close()
return jsonify(elements)
session.close()
return "ERROR"
def get_client_api(id, id_client)->str:
session = Session()
service = get_service(session, id)
client = get_client(session, id_client)
if request.method == 'GET':
if (service is not None) and (client is not None)\
and (client in service.client):
response = get_json_client(client)
session.close()
return response
session.close()
return "ERROR"
delete_client(session, client=client)
session.close()
return "DELETED"
def get_domain_reservations_api(id, id_domain):
session = Session()
service = get_service(session, id)
domain = get_domain(session, id_domain)
if (service is not None) and (domain is not None):
reservations = get_domain_reservations(session, domain=domain)
session.close()
return jsonify(reservations)
session.close()
return "ERROR"
def get_owner_api(id, id_owner) -> str:
session = Session()
service = get_service(session, id)
owner = get_owner(session, id_owner)
if request.method == 'GET':
if (service is not None) and (owner
is not None) and (owner
in service.owner):
response = get_json_owner(owner)
session.close()
return response
session.close()
return "ERROR"
delete_owner(session, owner=owner)
session.close()
return "DELETED"
def get_client_reservations_api(id, id_client):
session = Session()
service = get_service(session, id)
client = get_client(session, id_client)
if (service is not None) and (client is not None) and\
(client in service.client):
response = get_client_reservations(session, client=client)
session.close()
return jsonify(response)
session.close()
return "ERROR"
def create_domain_api(id, id_owner) -> str:
body = request.json
session = Session()
service = get_service(session, id)
owner = get_owner(session, id_owner)
if (service is not None) and (owner is not None) and (owner
in service.owner):
domain = create_domain(session, owner, body['name'],
body['information'], None,
datetime.datetime.now())
domain.url = "/service/%d/owner/%d/domain/%d" % (service.id, owner.id,
domain.id)
session.commit()
response = domain.get_dict()
session.close()
return json.dumps(response)
session.close()
return "ERROR"
def get_domain_api(id, id_owner, id_domain) -> str:
session = Session()
service = get_service(session, id)
owner = get_owner(session, id_owner)
domain = get_domain(session, id_domain)
if request.method == 'GET':
if (service is not None) and (owner is not None)\
and (domain is not None) and (owner in service.owner) \
and (domain in owner.domain):
response = get_json_domain(domain)
session.close()
return response
session.close()
return "ERROR"
delete_domain(session, domain=domain)
session.close()
return "DELETED"
def end_trip():
user_id = request.args.get('usr_id')
trip_id = request.args.get('trip_id')
session = Session()
if usr_exists(session, user_id):
user = get_usr_by_idauth(session, user_id)
trip = get_trip(session, trip_id)
if (trip is not None) and trip_belongs_usr(session, user.id, int(trip_id)):
url = URL_RESERVATION + str(BOOKING_SERVICE_ID) + "/domain/" +\
str(trip.id_domain_booking) + "/get_dom_reservations"
r = requests.get(url)
reservations = r.json()
token_list = list()
#End Trip Trip Follower
requests.post(URL_TRIP_FOLLOWER + "/end_trip", params={'TripId':trip.id_iptf})
for res in reservations:
usr_client = get_usr_by_idclient(session, res["client_id"])
payment_info = json.loads(res["information"])
payment_bdy = {
"targetID" : user.mail,
"sourceID" : IKER_MAIL,
"amount" : res["price"],
"briefDescription": "None"
}
token_list.append({
"usr_id" : usr_client.id,
"payment_token" : payment_info["ttoken"],
"amount" : res["price"]
})
requests.post(URL_PAYMENT + "completePayment", json=payment_bdy)
create_review(session, usr_client, user)
delete_trip(session, trip=trip)
session.close()
return jsonify(token_list)
session.close()
return "ERROR"
def createUser():
authentication_id = request.args.get('usr_id')
body = request.json
session = Session()
if usr_exists(session, authentication_id):
session.close()
return "LOGGED IN"
elif set(["name", "information"]).issubset(set(body.keys())):
b_json = {"name": body["name"], "information": body["information"]}
r = requests.post(URL_RESERVATION + str(BOOKING_SERVICE_ID) + "/owner",
json=b_json)
owner_id = r.json()['id']
b_json = {"name": body["name"], "information": body["information"]}
r = requests.post(URL_RESERVATION + str(BOOKING_SERVICE_ID) +
"/client",
json=b_json)
client_id = r.json()['id']
access_token = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for _ in range(15))
usr = create_user(session, authentication_id, owner_id, client_id,
access_token, body["name"], body["img_url"],
body["mail"])
response = {"id": usr.id, "access_token": usr.access_token}
session.close()
return json.dumps(response)
session.close()
return "ERROR"
