def post(self, name):
"""adds a new event"""
data = Event.parser.parse_args()
if EventModel.find_event_by_name(name):
return {
"message":
"An event with name '{}' already exists. Please try to use another name"
.format(name)
}, 400
if not LocationModel.find_location_by_id(data["location_id"]):
return {
"message": "Location_id not valid".format(data["location_id"])
}, 400
if not OrganizerModel.find_organizer_by_id(data["organizer_id"]):
return {
"message": "Holder_id not valid".format(data["holder_id"])
}, 400
event = EventModel(name, **data)
try:
event.save_to_db()
except Exception as e:
return {
"message": "An error ocurred inserting the event: {}".format(e)
}, 500
return {"event_result": event.json()}, 201
def post(self):
parser = reqparse.RequestParser(
) # create parameters parser from request
# define al input parameters need and its type
parser.add_argument('name',
type=str,
required=True,
help="This field cannot be left blank")
parser.add_argument('place', type=str)
parser.add_argument('city', type=str)
parser.add_argument('date', type=str)
parser.add_argument('price', type=int)
parser.add_argument('total_available_tickets', type=int)
data = parser.parse_args()
for event in EventModel.query.all():
if (data['name'] == event.name):
return {
'message': 'Event {} already exists'.format(event.name)
}, 404
new_event = EventModel(data['name'], data['place'], data['city'],
data['date'], data['price'],
data['total_available_tickets'])
new_event.save_to_db()
return new_event.json(), 200
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, EventID):
'''
This function is used to upate or add an event if it does
not exists, we will not go through input check or more details
this is just an illstration basic project
'''
event = EventModel.find_event(EventID)
if not event:
# Same case as adding a new event
data = Event.parser.parse_args()
#** is used to unpack the dictionnnary
event = EventModel(EventID, **data)
# use this to update stop or tags
else:
data = Event.parser.parse_args()
# you may check data compatiblity here
if data['stop'] is not None: event.stop = data['stop']
if data['tags']:
# the format of tags: #tag1##tag2##tag3#
# if tag exist or empty don't add it
# you may set another rules of tag length, chars to remove...
if data['tags'] not in event.tags.split('##'):
event.tags += f"#{data['tags']}#"
try:
event.add_event()
except:
return {'message': 'Server error when trying to update event'}, 500
return event.json(), 200
def post(self, EventID):
'''
This function is used to add a new event to the database
Put may do the same but we prefer to separate them for future extension
'''
if EventModel.find_event(EventID):
return {
'message': f'An event with EventID {EventID} already exists'
}, 400
# The parser will detect automatically if the body is not well formatted so it
# it will throw a 400 bad request error reponse
data = Event.parser.parse_args()
event = EventModel(EventID, **data)
# if the server cannot add the event to database throw this 500 error reponse
try:
event.add_event()
except Exception as error:
return {
'message':
f'Server error occured when trying to save event {error}'
}, 500
return event.json(), 201
def post(self, group_id):
data = Event.parser.parse_args()
event = EventModel(data['name'], data['description'], data['location'],
data['date_time'], data['is_private'], group_id)
event.save_to_db()
return event.json(), 201
def post(self, id):
data = self.parser.parse_args()
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):
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 EventModel.find_by_uniqueness(data[n.NM], data[n.DATE],
data[n.CTY]):
return {n.MSG: "Event already in the data base"}, 409
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
try:
new_event = EventModel(data[n.NM], data[n.PLC], data[n.CTY],
data[n.DATE], data[n.PRC], data[n.TAT])
new_event.save_to_db()
return new_event.json(), 201
except:
return {n.MSG: "Error Description"}, 500
def post(self, name):
args = Event.parser1.parse_args()
if EventModel.find_by_name(name):
return {
'message':
"A event with name '{}' already exists.".format(name)
}, 400
event = EventModel(name, **args)
try:
event.save_to_db()
except:
return {
'message': 'An error occurred while 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, 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):
data = EventPost.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(**data)
try:
event.save_to_db()
except Exception as e:
print('Err: ' + str(e))
return {'message': 'An error occured inserting the event'}, 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(cls):
parser = reqparse.RequestParser()
parser.add_argument('name', type=str, required=True)
parser.add_argument('description', type=str, required=False)
parser.add_argument('start_date', type=datetime.fromisoformat, required=True)
parser.add_argument('end_date', type=datetime.fromisoformat, required=True)
parser.add_argument('duration_time', type=int, required=False)
parser.add_argument('image_url', type=str, required=False)
data = parser.parse_args()
current_userid = get_jwt_identity()
current_user = UserModel.find_by_id(current_userid)
if not current_user:
return {"status": Status.USER_NOT_FOUND, "message": "User not found"}, 403
start_date: datetime = data['start_date']
end_date: datetime = data['end_date']
if start_date > end_date:
return {"status": Status.INVALID_DATA, "message": "End_date cannot be before start_date"}, 403
duration_time = data['duration_time']
if duration_time and duration_time < 0:
return {"status": Status.INVALID_DATA, "message": "Duration_time cannot be less than 0"}, 403
event = EventModel(name=data['name'], description=data['description'], start_date=start_date, end_date=end_date, image_url=data['image_url'],
duration_time=duration_time)
admin_participant = ParticipantModel(user_id=current_user.id, role=Role.ADMIN)
event.participants.append(admin_participant)
event.invitation_link = str(uuid.uuid4())
event.save_to_db()
return {"status": Status.SUCCESS,
"message": "Event created successfully",
"event": event.json()
}, 201