def delete(self):
"""
Deletes a post or account
"""
data = administrator_action_parser.parse_args()
if (data["type"] == "account"):
if UserModel.find_by_email(data["identifier"]):
UserModel.find_by_email(data["identifier"]).delete_from_db()
return {
"status": "OK",
"message": "User deleted"
}
return {
"status": "Error",
"message": "User not found"
}
elif (data["type"] == "event"):
if EventModel.find_by_title(data["identifier"]):
EventModel.find_by_title(data["identifier"]).delete_from_db()
return {
"status": "OK",
"message": "Event deleted"
}
return {
"status": "Error",
"message": "Event not found"
}
return {
"status": "Error",
"message": "Invalid type"
}
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):
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 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 get(self, name):
args = Event.parser.parse_args()
if safe_str_cmp(name, "events"):
event = EventModel.find_by_timeline(**args)
if event:
return {'events': [x.json() for x in event]}
else:
event = EventModel.find_by_name(name)
if event:
return {'events': event.json()}
#return {'events': [x.json() for x in event]}
return {'message': '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 delete(cls):
user_id = get_jwt_identity()
user = UserModel.find_by_id(ObjectId(user_id))
if not user:
return {
"status": Status.USER_NOT_FOUND,
"message": "Current user not found"
}, 404
user.delete_from_db()
events_deleted = 0
events: List[EventModel] = EventModel.find_all_by_admin_id(
admin_id=user.id)
for event in events:
if len(
list(
filter(
lambda participant: participant.role == Role.ADMIN,
event.participants))) == 1:
event.delete()
events_deleted += 1
message = "User deleted" if events_deleted < 1 else f"User deleted with {events_deleted} event[s] with no longer admin left"
return {"status": Status.SUCCESS, "message": message}, 200
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, 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 delete(self, id):
"""deletes an event by name"""
event = EventModel.find_event_by_id(id)
if event:
event.delete_from_db()
return {"message": "Event deleted"}
return {"message": "Event not found"}
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 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 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 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 get(self, EventID):
'''
This method used to an event by a given ID
'''
event = EventModel.find_event(EventID)
if event:
return event.json()
return {'message': 'event not found'}, 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, 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 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 put(cls, event_id: str):
parser = reqparse.RequestParser()
parser.add_argument('name', type=str, required=False)
parser.add_argument('description', type=str, required=False)
parser.add_argument('start_date', type=datetime.fromisoformat, required=False)
parser.add_argument('end_date', type=datetime.fromisoformat, required=False)
parser.add_argument('duration_time', type=int, required=False)
parser.add_argument('image_url', type=str, required=False)
data = parser.parse_args()
if not ObjectId.is_valid(event_id):
return {"status": Status.INVALID_FORMAT, "message": "Id is not valid ObjectId"}, 400
current_userid = get_jwt_identity()
current_user = UserModel.find_by_id(current_userid)
if not current_user:
return {"status": Status.USER_NOT_FOUND, "message": "Current user not found"}, 403
event: EventModel = EventModel.find_by_id_and_admin_id(ObjectId(event_id), current_userid)
if not event:
return {"status": Status.NOT_FOUND, "message": "Event not found with admin as current user"}, 404
if data['name']:
if len(data['name']) < 3:
return {"status": Status.INVALID_FORMAT, "message": "name must be at least 3 chars long"}, 400
event.name = data['name']
if data['description']:
event.description = data['description']
start_date: datetime = data['start_date']
end_date: datetime = data['end_date']
if start_date and end_date:
if start_date > end_date:
return {"status": Status.INVALID_DATA, "message": "End_date cannot be before start_date"}, 403
event.start_date = start_date
event.end_date = end_date
elif end_date:
if event.start_date and event.start_date > end_date:
return {"status": Status.INVALID_DATA, "message": "End_date cannot be before start_date"}, 403
event.end_date = end_date
elif start_date:
if event.end_date and event.end_date < start_date:
return {"status": Status.INVALID_DATA, "message": "End_date cannot be before start_date"}, 403
event.start_date = start_date
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.duration_time = duration_time
if data['image_url']:
event.image_url = data['image_url']
event.save_to_db()
return {"status": Status.SUCCESS, "event": event.json()}, 200
def rpc_push_job(exec_id, interface_id, job_id, server_host, port, params_value, server_dir, server_script, return_code,
status, date_format='%Y%m%d', run_date=''):
"""
RPC分发任务
1.替换$date变量
:param exec_id: 执行id
:param interface_id: 任务流id
:param job_id: 任务id
:param server_host: RPC执行服务器域名
:param port: RPC执行服务器端口
:param params_value: 参数值字符串
:param server_dir: 脚本目录
:param server_script: 运行脚本
:param return_code: 状态返回码
:param status: 任务状态
:param date_format: 日期格式
:param run_date: 数据日期
:return:
"""""
try:
# rpc分发任务
client = Connection(server_host, port)
# 任务参数中数据日期变量为T-1
if not run_date:
run_time = (date.today() + timedelta(days=-1)).strftime(date_format)
else:
run_time = run_date
params = params_value.split(',') if params_value else []
client.rpc.event_execute(
exec_id=exec_id,
interface_id=interface_id,
job_id=job_id,
server_dir=server_dir,
server_script=server_script,
return_code=return_code,
params=[item if item != '$date' else run_time for item in params],
status=status
)
client.disconnect()
return ''
except:
err_msg = 'rpc连接异常: host: %s, port: %s' % (server_host, port)
# 添加执行任务详情日志
EventModel.add_event_exec_detail_job(db.etl_db, exec_id, interface_id, job_id, 'ERROR', server_dir,
server_script, err_msg, 3)
# 修改数据库, 分布式锁
with MysqlLock(config.mysql.etl, 'event_lock_%s' % exec_id):
# 修改执行详情表状态[失败]
EventModel.update_event_exec_job_status(db.etl_db, exec_id, interface_id, job_id, 'failed')
# 修改执行任务流状态[失败]
EventModel.update_event_exec_interface_status(db.etl_db, exec_id, interface_id, -1)
# 修改执行主表状态[失败]
EventModel.update_event_execute_status(db.etl_db, exec_id, -1)
log.error(err_msg, exc_info=True)
return err_msg
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(cls, event_id: str):
parser = reqparse.RequestParser()
parser.add_argument('username', type=str, required=True)
data = parser.parse_args()
if not ObjectId.is_valid(event_id):
return {
"status": Status.INVALID_FORMAT,
"message": "Id is not valid ObjectId"
}, 400
current_userid = get_jwt_identity()
current_user = UserModel.find_by_id(ObjectId(current_userid))
if not current_user:
return {
"status": Status.USER_NOT_FOUND,
"message": "Current user not found"
}, 403
user_to_update = UserModel.find_by_username(data['username'])
if not user_to_update:
return {
"status": Status.USER_NOT_FOUND,
"message": "User you want to add not found"
}, 403
if user_to_update.id == current_user.id:
return {
"status": Status.INVALID_DATA,
"message": "Cannot revoke admin to yourself"
}, 403
event = EventModel.find_by_id_and_admin_id(ObjectId(event_id),
current_user.id)
if not event:
return {
"status": Status.NO_ADMIN,
"message": "Event with admin as current user not found"
}, 403
participant_to_update: ParticipantModel = next(
filter(
lambda participant: participant.user_id == user_to_update.id,
event.participants), None)
if not participant_to_update:
return {
"status": Status.USER_NOT_FOUND,
"message": "User you want to revoke admin is not in the event"
}, 403
participant_to_update.role = Role.MEMBER
event.save()
return {
"status": Status.SUCCESS,
"message": "Admin revoked",
"participant": participant_to_update.json()
}, 200
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 delete(self, name):
if safe_str_cmp(name, "events"):
[event.delete_from_db() for event in EventModel.query.all()]
else:
event = EventModel.find_by_name(name)
if event:
event.delete_from_db()
return {'message': 'Event deleted'}
def post(cls, event_id: str):
parser = reqparse.RequestParser()
parser.add_argument('username', type=str, required=True)
data = parser.parse_args()
if not ObjectId.is_valid(event_id):
return {
"status": Status.INVALID_FORMAT,
"message": "Id is not valid ObjectId"
}, 400
current_userid = get_jwt_identity()
current_user = UserModel.find_by_id(ObjectId(current_userid))
if not current_user:
return {
"status": Status.USER_NOT_FOUND,
"message": "Current user not found"
}, 403
user_to_remove = UserModel.find_by_username(data['username'])
if not user_to_remove:
return {
"status": Status.USER_NOT_FOUND,
"message": "User you want to add not found"
}, 403
event = EventModel.find_by_id_and_admin_id(ObjectId(event_id),
current_user.id)
if not event:
return {
"status": Status.USER_NOT_FOUND,
"message": "Event with admin as current user not found"
}, 403
is_success = event.remove_participant(user_id=user_to_remove.id)
if not is_success:
return {
"status": Status.ERROR,
"message": "Some error occured"
}, 400
event.reload()
if len(
list(
filter(lambda participant: participant.role == Role.ADMIN,
event.participants))) == 0:
event.delete()
return {
"status": Status.SUCCESS,
"message": "Event removed because last admin was removed"
}, 200
return {
"status": Status.SUCCESS,
"message": "User removed from an event"
}, 200
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.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 test_event_model_with_blank_values(self):
with self.assertRaises(ValueError):
EventModel(
title='',
description=
'Alexander Hamilton was born and spent part of his childhood in Charlestown.',
occurred_on='1757-01-11')
with self.assertRaises(ValueError):
EventModel(title='Birth of a Legend',
description='',
occurred_on='1757-01-11')
with self.assertRaises(ValueError):
EventModel(
title='',
description=
'Alexander Hamilton was born and spent part of his childhood in Charlestown.',
occurred_on='')
