def put(self, id):
data = self.parser()
with lock.lock:
event = EventModel.find_by_id(id)
if id and EventModel.find_by_id(id):
event.delete_from_db()
event = EventModel(data['name'], data['place'], data['city'],
data['date'], data['price'],
data['available_tickets'])
event.save_to_db()
return {'message': "Success, event added"}, 201
else:
return {'message': "Not found"}, 404
def post(self, id_event):
event = EventModel.find_by_id(id_event)
if event:
parser = reqparse.RequestParser(
) # create parameters parser from request
# define al input parameters need and its type
parser.add_argument(n.NM,
type=str,
required=True,
help="Artistic name of the artist")
parser.add_argument(n.CTRY,
type=str,
required=True,
help="Country nationality of the artist")
parser.add_argument(n.GNR,
type=str,
required=True,
help="Main genre of the artist")
data = parser.parse_args()
with lock.lock:
artist = ArtistModel.find_by_name(data[n.NM])
if artist and artist.country == data[
n.CTRY] and artist.genre == data[n.GNR]:
event.artists.append(artist)
event.save_to_db()
return event.json(), 200
else:
return {n.MSG: "Artist not found"}, 409
else:
return {n.MSG: "Event not found"}, 404
def get(self, id):
with lock.lock:
event = EventModel.find_by_id(id)
if event:
return {'event': event.json()}, 200
else:
return {"message": "Not found"}, 404
def post(cls, event_id: str):
event: EventModel = EventModel.find_by_id(ObjectId(event_id))
current_user_id = get_jwt_identity()
for participant in event.participants:
if str(current_user_id) == str(participant.user_id):
if participant.role == Role.ADMIN:
song_ids = RecommendationAlgorithmSVD.run(event_id)
event.playlist = song_ids
event.save_to_db()
songs: List[SongModel] = SongModel.find_all_by_ids(
song_ids)
return {
"status": Status.SUCCESS,
"event": event.json_with_playlist(songs)
}, 200
else:
return {
"status": Status.NO_ADMIN,
"message": "User is not an admin"
}, 403
return {
"status": Status.USER_NOT_FOUND,
"message": "User is not event participant"
}, 403
def put(self, id):
data = Event.parser.parse_args()
data.start_time = datetime.datetime.strptime(
data.start_time, '%Y-%m-%d %H:%M:%S')
data.end_time = datetime.datetime.strptime(
data.end_time, '%Y-%m-%d %H:%M:%S')
data.event_date = datetime.datetime.strptime(
data.event_date, '%Y-%m-%d %H:%M:%S')
event = EventModel.find_by_id(id)
if event is None:
event = EventModel(**data)
else:
event.name = data['name'] or event.name
event.category = data['category'] or event.category
event.location = data['location'] or event.location
event.start_time = data['start_time'] or event.start_time
event.end_time = data['end_time'] or event.end_time
event.event_date = data['event_date'] or event.event_date
event.owner = data['owner'] or event.owner
event.status = data['status'] or event.status
event.quota = data['quota'] or event.quota
event.price = data['price'] or event.price
event.save_to_db()
return event.json()
def put(self, id):
event = EventModel.find_by_id(id)
if event:
parser = reqparse.RequestParser(
) # create parameters parser from request
# define al input parameters need and its type
parser.add_argument(n.NM,
type=str,
required=True,
help="Name of the event")
parser.add_argument(
n.PLC,
type=str,
required=True,
help="Place or area where the event takes place")
parser.add_argument(n.CTY,
type=str,
required=True,
help="City that holds the event")
parser.add_argument(n.DATE,
type=str,
required=True,
help="Date when the event takes place")
parser.add_argument(n.PRC,
type=int,
required=True,
help="Weighted average price of the event")
parser.add_argument(
n.TAT,
type=int,
required=True,
help="Number of people that can attend the event")
data = parser.parse_args()
with lock.lock:
if data[n.PRC] < 0:
return {n.MSG: "Negative price not allowed"}, 400
if data[n.TAT] < 0:
return {
n.MSG: "Negative number of tickets not possible"
}, 400
aux_event = EventModel.find_by_uniqueness(
data[n.NM], data[n.DATE], data[n.CTY])
if aux_event and aux_event.id != id:
return {
n.MSG: "Event already in the data base with another ID"
}, 409
try:
event.modify_from_db(data[n.NM], data[n.PLC], data[n.CTY],
data[n.DATE], data[n.PRC],
data[n.TAT])
return event.json(), 200
except:
return {n.MSG: "Error Description"}, 500
else:
return {n.MSG: "Event not found"}, 404
def get(cls, **kwargs):
# Statistics for a specific event
if 'event_id' in kwargs:
event = EventModel.find_by_id(kwargs['event_id'])
if not event:
return {"message": "Event not found."}, 404
else:
return cls.build_event_response(event), 200
# Statistics for a specific ticket type
elif 'ticket_type' in kwargs:
if not valid_ticket_type(kwargs['ticket_type']):
return {
'message':
'That is not a valid ticket type. '
'Please choose between {}, {} or {}.'.format(*ticket_types)
}, 400
kwargs['ticket_type'] = convert_ticket_type(kwargs['ticket_type'])
return cls.build_ticket_response(kwargs['ticket_type'])
else:
# Statistics for every event in the database
response = {'events': []}
for event in EventModel.query.all():
response['events'].append({
event.name: {
'id': event.id,
**cls.build_event_response(event)
}
})
return response
def post(self, **kwargs):
reservation_json = request.get_json()
if 'reservation_id' not in kwargs:
if not valid_ticket_type(reservation_json['ticket_type']):
return {
'message':
'That is not a valid ticket type. '
'Please choose between {}, {} or {}.'.format(*ticket_types)
}, 400
reservation_json['ticket_type'] = convert_ticket_type(
reservation_json['ticket_type'])
user_id = get_jwt_identity()
reservation_json['user_id'] = user_id
event = EventModel.find_by_id(reservation_json['event_id'])
if event:
if not event.check_availability(
reservation_json['ticket_type']):
return {
'message':
'We are sorry to inform that {} '
'tickets are sold out.'.format(
reservation_json['ticket_type'])
}, 200
else:
return {'message': 'That is not a valid event'}, 404
if not validate_request(reservation_json, ReservationModel):
return {
'message':
'Request invalid, please re-check your parameters.'
}, 400
# Unpack the request into a new reservation model
reservation = ReservationModel(**reservation_json)
# It is needed to remove one available ticket, since now it is reserved
reservation.update_event()
reservation.save_to_db()
scheduler.add_job(reservation.update_ticket_amount,
'date',
id=reservation.id,
run_date=reservation.expire_at)
return {"message": "Your reservation was successful."}, 201
else:
# Here the user is trying to pay for a reservation, since an ID was passed in the request
reservation_json['reservation_id'] = kwargs['reservation_id']
reservation = ReservationModel.find_by_id(kwargs['reservation_id'])
if reservation:
if reservation.expired:
return {
'message':
'Sorry, that reservation is already expired. Please make a new reservation and '
'pay after.'
}, 400
reservation_json['reservation'] = reservation
# Popping keys from the dictionary, since this dict will be passed on later to our payment gateway
reservation_json.pop('reservation_id', None)
return self.pay(**reservation_json)
else:
return {
"message": "That reservation was not found on the system."
}, 404
def put(self, query):
event = EventModel.find_by_id(query)
if event:
event = self.update_event(event)
else:
event = self.parse_to_new_event(query)
event.save_to_db()
return event.json()
def delete(self, event_id):
event = EventModel.find_by_id(event_id)
if event:
event.delete_from_db()
return {'message': 'Event deleted!'}, 200
return {'message': 'Event with that ID not found.'}, 404
def delete(self, id):
with lock.lock:
event = EventModel.find_by_id(id)
if event:
event.delete_from_db()
return {'message': 'Event deleted'}, 200
else:
return {'message': "Event not found"}, 404
def delete(self, id):
with lock.lock:
event = EventModel.find_by_id(id)
if event:
event.delete_from_db()
return {n.MSG: "Event deleted successfully"}, 200
else:
return {n.MSG: "Event not found"}, 404
def get(self):
dic = {}
date = request.args.get('date')
if date:
dic["date"] = date.split(',')
adv_origin = request.args.get('adv_origin')
if adv_origin:
dic["adv_origin"] = adv_origin.split(',')
adv_organization = request.args.get('adv_organization')
if adv_organization:
dic["adv_organization"] = adv_organization.split(',')
adv_camp = request.args.get('adv_camp')
if adv_camp:
dic["adv_camp"] = adv_camp.split(',')
target_sector = request.args.get('target_sector')
if target_sector:
dic["target_sector"] = target_sector.split(',')
target_name = request.args.get('target_name')
if target_name:
dic["target_name"] = target_name.split(',')
target_origin = request.args.get('target_origin')
if target_origin:
dic["target_origin"] = target_origin.split(',')
reference = request.args.get('reference')
if reference:
dic["reference"] = reference.split(',')
status = request.args.get('status')
if status:
dic["status"] = status.split(',')
details = request.args.get('details')
if details:
dic["details"] = details.split(',')
type = request.args.get('type')
if type:
dic["type"] = type.split(',')
reporter = request.args.get('reporter')
if reporter:
dic["reporter"] = reporter.split(',')
query = "SELECT * FROM data.Events WHERE "
for k, v in dic.items():
if len(v) == 1:
query += f"{k} = '{v[0]}' AND "
else:
query += '('
for value in v:
query += f"{k} = '{value}' OR "
query = query[:-4]
query += ") AND "
query = query[:-5]
sql_query = text(query)
result = db.engine.execute(sql_query)
events = [EventModel.find_by_id(row[0]).json() for row in result]
headers = {'content-type': 'text/html'}
return make_response(render_template("events.html", events=events),
200, headers)
def delete(self, id):
event = EventModel.find_by_id(id)
if event:
if event.owner == get_jwt_identity():
event.delete_from_db()
else:
return {'message': 'Non autorizzato'}, 403
return {'message': 'Event deleted'}
def json(self):
event = EventModel.find_by_id(self.id_event)
return {
"Id": self.id_event,
"Username": self.username,
"Event_name": event.name,
"Event_date": event.date,
"Event_city": event.city,
"Tickets_bought": self.tickets_bought
}
def get(self, id):
try:
event = EventModel.find_by_id(id)
except:
return {'message': 'An error occured searching the event'}, 500
if event:
return event.json()
return {'message': 'Event not found'}, 404 # not-found
def get(self, id):
with lock.lock:
event = EventModel.find_by_id(id)
if event:
artists = event.artists
return {
'artists': list(map(lambda x: x.json(), artists))
}, 200 if artists else 404
else:
return {'message': "Event not found"}, 404
def json(self):
event = EventModel.find_by_id(self.event_id)
return {
'id': self.id,
'price': self.price,
'quantity': self.quantity,
'seat_num': self.seat_num,
'event': event.json(),
'order_id': self.order_id
}
def delete(self, id_event, id_artist):
with lock.lock:
event = EventModel.find_by_id(id_event)
artist = ArtistModel.query.join(
ArtistModel.events).filter(EventModel.id == id_event).filter(
ArtistModel.id == id_artist).first()
if artist:
event.artists.remove(artist)
return {n.MSG: "Artist deleted successfully"}, 200
else:
return {n.MSG: "Artist or event not found"}, 404
def get(cls, **kwargs):
if '_id' in kwargs:
# get occurrence by id
event = EventModel.find_by_id(kwargs['_id'])
if event:
return event_schema.dump(event), 200
else:
return {"message": "Event not found."}, 404
else:
event = EventModel.find_by_name(kwargs['name'])
if event:
return event_schema.dump(event), 200
else:
return {"message": "Event not found."}, 404
def json(self):
event = EventModel.find_by_id(self.id_event).json()[n.EVNT]
return {
n.ORDR: {
n.ID: self.id,
n.USR: self.username,
n.EVNTNM: event[n.NM],
n.EVNTDT: event[n.DATE],
n.EVNTCTY: event[n.CTY],
n.TCK: self.tickets_bought,
}
}
def get(cls, event_id: str):
if not ObjectId.is_valid(event_id):
return {"status": Status.INVALID_FORMAT, "message": "Id is not valid ObjectId"}, 400
event: EventModel = EventModel.find_by_id(ObjectId(event_id))
if not event:
return {"status": Status.NOT_FOUND, "message": "Event not found."}, 404
participants_id = list(map(lambda participant: participant.user_id, event.participants))
users: List[UserModel] = UserModel.find_all_by_ids(participants_id)
songs: List[SongModel] = SongModel.find_all_by_ids(event.playlist)
return {"status": Status.SUCCESS, "event": event.json_with_playlist(songs, users)}, 200
def get(self, id_event, id_artist):
with lock.lock:
event = EventModel.find_by_id(id_event)
if event:
artist = next(
filter(lambda x: str(x.id) == str(id_artist),
event.artists), None)
if artist:
return {'artist': artist.json()}, 200 if artist else 404
else:
return {
'message':
"Artist with id [{}] not found".format(id_artist)
}, 404
else:
return {
'message': "Event with id [{}] not found".format(id_event)
}, 404
def delete(self, id_event, id_artist):
with lock.lock:
event = EventModel.find_by_id(id_event)
if event:
for a in event.artists:
print("a.id : {}, id_artist: {}, a.id == id_artist: {}".
format(a.id, id_artist, a.id == id_artist))
print("artist {}".format(type(id_artist)))
print("a {}".format(type(a.id)))
if a.id == id_artist:
event.artists.remove(a)
event.save_to_db()
return {'message': "Success"}, 200
return {
'message': "Artist with id {} not found".format(id_artist)
}, 404
else:
return {'message': "Event not found"}, 404
def put(self, id):
data = self.parser.parse_args()
event = EventModel.find_by_id(id)
if event:
try:
event.update(data.name, data.startdate, data.enddate, data.org,
data.place, get_jwt_identity())
except:
return {"message": "Non autorizzato"}, 403
else:
event = EventModel(data.name, data.startdate, data.enddate,
data.org, data.place, get_jwt_identity())
try:
event.save_to_db()
except:
return {"message": "An error occurred creating the event."}, 500
return event.json(), 201
def post(self, id=None):
data = self.parser()
with lock.lock:
if id and EventModel.find_by_id(id):
return {
'message': "Event with id [{}] already exists".format(id)
}, 404
else:
event = EventModel(data['name'], data['place'], data['city'],
data['date'], data['price'],
data['available_tickets'])
print(event)
try:
event.save_to_db()
except Exception as e:
print(e)
return {"message": 'error'}, 500
return event.json(), 201
def put(self, event_id):
data = Event.parser.parse_args()
event = EventModel.find_by_id(event_id)
if event is None:
event = EventModel(data['name'], data['description'],
data['location'], data['date_time'],
data['is_private'], group_id)
else:
event.name = data['name']
event.description = data['description']
event.location = data['location']
event.date_time = datetime.strptime(data['date_time'],
'%Y/%m/%d %H:%M')
event.is_private = data['is_private']
event.save_to_db()
return event.json(), 200
def post(self, id_event, id_artist=None):
with lock.lock:
data = self.parser()
artist = ArtistModel.find_by_id(
id_artist) if id_artist else ArtistModel.find_by_name(
data['name'])
event = EventModel.find_by_id(id_event)
if not event:
return {
'message': "Event with id [{}] not found".format(id_event)
}, 404
else:
if not artist:
artist = ArtistModel(data['name'], data['country'],
data['genre'])
artist.save_to_db()
try:
event.artists.append(artist)
event.save_to_db()
except:
return {"message": "Error Description"}, 500
return {"message": "Success"}, 201
def post(self, username):
user = AccountsModel.find_by_username(username)
if user:
parser = reqparse.RequestParser()
parser.add_argument(n.IDEVNT, type=int, required=True, help="Id of the event")
parser.add_argument(n.TCK, type=int, required=True, help="Number of tickets the user wants to buy")
data = parser.parse_args()
with lock.lock:
if username == g.user.username:
event = EventModel.find_by_id(data[n.IDEVNT])
if event:
price = event.price*data[n.TCK]
if user.available_money >= price:
if event.total_available_tickets >= data[n.TCK]:
try:
user.pay(price)
event.sell(data[n.TCK])
new_order = OrdersModel(data[n.IDEVNT], data[n.TCK])
user.orders.append(new_order)
new_order.save_to_db()
user.save_to_db()
event.save_to_db()
return new_order.json(), 201
except:
return {n.MSG: "Error Description"}, 500
else:
return {n.MSG: "The event does not have enough available ticket"}, 400
else:
return {n.MSG: "The user does not have enough money"}, 400
else:
return {n.MSG: "Event not found"}, 404
else:
return {n.MSG: "Username error"}, 400
else:
return {n.MSG: "Username not found"}, 404
def post(self, username):
data = self.parser()
with lock.lock:
if username == g.user.username:
a = AccountsModel.find_by_username(username)
e = EventModel.find_by_id(data['event_id'])
if e.total_available_tickets >= data["tickets_bought"]:
if a.available_money >= e.price * data["tickets_bought"]:
e.total_available_tickets = EventModel.total_available_tickets - data[
"tickets_bought"]
a.available_money -= data["tickets_bought"] * e.price
o = OrdersModel(e.id, data["tickets_bought"])
a.orders.append(o)
db.session.commit()
return {"order": o.json()}, 201
else:
return {'message': 'Not enough money'}, 501
else:
return {'message': 'No enough tickets'}, 502
else:
return {
'message':
'Endpoint username and g.user.username not equal'
}, 400