def create(current_user, user_id, limit=4, page=1):
""" Method to create event."""
event = request.get_json()
name=event['name'].strip()
category=event['category']
location=event['location']
date=event['date']
description=event['description']
new_event = validate_data(event)
if new_event is not event:
return jsonify({"message":new_event}), 400
existing=Events.query.filter_by(name=name).filter_by(category=category).filter_by\
(created_by=user_id).filter_by(location=location).first()
if existing:
response = {"message" : "A similar event already exists!"}
return make_response(jsonify(response)), 302
try:
created_event = Events(name=name, category=category, location=location,
date=date, description=description, created_by = user_id)
created_event.save()
response = jsonify({
'id': created_event.id, 'name' : created_event.name, 'category' : created_event.category,
'location' : created_event.location, 'date' : created_event.date,
'description' : created_event.description, 'created_by' : created_event.created_by,
'message': 'Event successfully created'
})
except KeyError:
response = {"message": "There was an error creating the event, please try again"}
return make_response(jsonify(response)), 500
return make_response(response), 201
def create():
"""a route to handle creating an event"""
event_details = request.get_json()
check_details = validate_data(event_details)
check_date = validate_date(event_details['event_date'])
#check if the data was confirmed valid
if check_details is not "valid":
return jsonify({"message" : check_details}), 400
elif check_date is not "valid":
return jsonify({"message" : check_date}), 400
else:
name = event_details['name']
description = event_details['description']
category = event_details['category']
location = event_details['location']
event_date = event_details['event_date']
created_by = g.user
#check if the user has an event with a similar name and location
existing_event = [event for event in g.user.events if event.name == name \
and event.location == location]
if not existing_event:
#create the event if does not exist
event = Events(name=name, description=description, category=category, \
location=location, event_date=event_date, created_by=created_by)
event.save()
res = event.to_json()
return jsonify(res), 201
return jsonify({"message" : "you have a similar event in the same location"}), 302
def events_filter():
"""filter events by location or category"""
#get the incoming parameters
location = request.args.get("location")
category = request.args.get("category")
#get the given page and number of events or set them to default
page = request.args.get("page", default=1, type=int)
per_page = request.args.get("limit", default=15, type=int)
#check which parameter was given and use it to query the database
if location and category:
#if both location and category have been given,filter by both
found_events = Events.filter_events(location, category, page, per_page)
if found_events.items:
event_list = make_event_list(found_events.items)
return jsonify(event_list), 200
return jsonify({"message" : "there are no more {} events in {}".format(category, location)}), 404
elif location:
found_events = Events.get_events_by_location(location, page, per_page)
if found_events.items:
event_list = make_event_list(found_events.items)
return jsonify(event_list), 200
return jsonify({"message" : "there are no more events in {}".format(location)}), 404
elif category:
found_events = Events.get_events_by_category(category, page, per_page)
if found_events.items:
event_list = make_event_list(found_events.items)
return jsonify(event_list), 200
return jsonify({"message" : "there are no more {} events".format(category)}), 404
else:
return jsonify({"message" : "can not search events with the given parameter"}), 400
def create_contact_record(request, first_name, last_name, email, subject,
message):
"""
Creates Users, Emails, and Events entries for a contact submission for a request.
Sends email with message to all agency users associated with the request.
:param request: request object
:param first_name: sender's first name
:param last_name: sender's last name
:param email: sender's email
:param subject: subject of email
:param message: email body
"""
if current_user == request.requester:
user = current_user
else:
user = Users(guid=generate_guid(),
email=email,
first_name=first_name,
last_name=last_name,
email_validated=False,
terms_of_use_accepted=False,
is_anonymous_requester=True)
create_object(user)
create_object(
Events(request_id=request.id,
user_guid=None,
type_=event_type.USER_CREATED,
new_value=user.val_for_events))
body = "Name: {} {}\n\nEmail: {}\n\nSubject: {}\n\nMessage:\n{}".format(
first_name, last_name, email, subject, message)
agency_emails = get_assigned_users_emails(request.id)
email_obj = Emails(request.id,
PRIVATE,
to=','.join([
email.replace('{', '').replace('}', '')
for email in agency_emails
]),
cc=None,
bcc=None,
subject=subject,
body=body)
create_object(email_obj)
create_object(
Events(request_id=request.id,
user_guid=user.guid,
type_=event_type.CONTACT_EMAIL_SENT,
response_id=email_obj.id,
new_value=email_obj.val_for_events))
send_contact_email(subject, agency_emails, message, email)
def events():
"""getting all events pertaining a user"""
if request.method == 'POST':
event = request.args.get('event')
if Events.create_event(event) == "That event already exists":
return jsonify({'message': 'That event already exists'})
else:
if Events.create_event(event) == "Event added":
return jsonify("Event Added")
else:
if Events.get_events() == "You do not have events":
return jsonify({'message': 'You do not have events'})
else:
if Events.get_events() == "There are no events":
return jsonify({'message': 'There are no events to show'})
def addevent():
form = NewEventForm(request.form)
if request.method == 'POST' and form.validate_on_submit():
#user = User(form.first_name.data, form.last_name.data, form.username.data,
# form.username.data, form.email.data, form.enrollment.data,
# form.college_name.data)
event = Events(form.event_name.data, form.address.data, form.fees.data)
event.start_date = form.start_date.data
event.end_date = form.end_date.data
db.session.add(event)
db.session.commit()
return render_template('addevent.html',isadded=True)
return render_template('addevent.html',form=form, isadded=False)
def addevent():
form = NewEventForm(request.form)
if request.method == 'POST' and form.validate_on_submit():
#user = User(form.first_name.data, form.last_name.data, form.username.data,
# form.username.data, form.email.data, form.enrollment.data,
# form.college_name.data)
event = Events(form.event_name.data, form.address.data, form.fees.data)
event.start_date = form.start_date.data
event.end_date = form.end_date.data
db.session.add(event)
db.session.commit()
return render_template('addevent.html', isadded=True)
return render_template('addevent.html', form=form, isadded=False)
def manipulate_event(event_id):
"""update or delete an event"""
event = Events.get_event_by_id(event_id)
if event:
#maeke sure the events is modified by the right person
if event.created_by.username == g.user.username:
if request.method == 'PUT':
event_details = request.get_json() #get the incoming details
#update the details accordingly
event.name = event_details['name']
event.description = event_details['description']
event.category = event_details['category']
event.location = event_details['location']
event.event_date = event_details['event_date']
#save the event back to the database
event.save()
return jsonify({"message" : "event updated successfully"}), 200
elif request.method == 'GET':
#return the event with the given id
found_event = event.to_json()
return jsonify(found_event), 200
else:
#if the request method is delete
event.delete()
return jsonify({"message" : "event deleted successfully"}), 200
return jsonify({"message" : "you can not modify the event"})
return jsonify({"message" : "no event with given id found"}), 404
def create_user_request_event_object(events_type,
user_request,
old_permissions=None,
old_point_of_contact=None,
user=current_user):
"""
Create an Event for the addition, removal, or updating of a UserRequest and insert into the database.
Args:
events_type (str): event type from the constants defined in constants.event_type.
user_request (UserRequests): UserRequests object.
old_permissions (int): Value of permissions for the request.
user (Users): Users object that represents the user performing the user_request modification
Returns:
Events: The event object representing the change made to the user.
"""
previous_value = {'user_guid': user_request.user_guid}
if old_permissions is not None:
previous_value['permissions'] = old_permissions
if old_point_of_contact is not None:
previous_value['point_of_contact'] = old_point_of_contact
return Events(
user_request.request_id,
user.guid,
events_type,
previous_value=previous_value,
new_value=user_request.val_for_events,
timestamp=datetime.utcnow(),
)
def create_event():
form = EventForm()
form.artistName.choices = [(artist1.id, artist1.name)
for artist1 in Artist.query.all()]
form.venueName.choices = [(venue.id, venue.location)
for venue in Venues.query.all()]
if form.validate_on_submit():
venue = Venues.query.filter_by(id=form.venueName.data).first()
names = form.artistName.data
flash('Venue = {}'.format(venue))
nameList = []
for i in range(len(names)):
nameList.append(names[i])
flash(' Name List{}'.format(nameList[i]))
event1 = Events(name=form.eventName.data,
price='S400',
venue_id=venue.id,
event_date=form.eventDate.data)
db.session.add(event1)
db.session.commit()
for a in range(len(nameList)):
value = nameList[a]
a2e = ArtistToEvent(Artist_id=value, Event_id=event1.id)
db.session.add(a2e)
db.session.commit()
return render_template('create_event.html', form=form)
def create_event_post(event_date, event_location, event_leader, start_time,
end_time, sponsor, author, title, content, tags):
"""
Util function for creating a EventPost object. Function will take parameters passed in from the form
and create a event post along with the event object.
"""
event_post = EventPosts(event_date=event_date,
event_location=event_location,
event_leader=event_leader,
start_time=start_time,
end_time=end_time,
sponsor=sponsor,
author=author,
title=title,
content=content,
tags=tags)
create_object(event_post)
# Create event_post_created Event
event = Events(post_id=event_post.id,
user_id=author,
type="event_post_created",
previous_value={},
new_value=event_post.val_for_events)
create_object(event)
return event_post.id
def update_status(suborder: Suborders, comment: str, new_status: str):
"""Updates the status of a row from the Suborders table.
Args:
suborder: A Suborders instance.
comment: Any additional information about the updating of the status.
new_status: The value of the status to be updated to.
"""
prev_event = Events.query.filter(
Events.suborder_number == suborder.id,
Events.new_value['status'].astext == suborder.status).order_by(
Events.timestamp.desc()).first()
previous_value = {}
new_value = {}
previous_value['status'] = suborder.status
if prev_event is not None and 'comment' in prev_event.new_value:
previous_value['comment'] = prev_event.new_value['comment']
update_object({'status': new_status}, Suborders, suborder.id)
new_value['status'] = new_status
if comment:
new_value['comment'] = comment
event = Events(suborder.id, event_type.UPDATE_STATUS, current_user.email,
previous_value, new_value)
create_object(event)
suborder.es_update()
def remove_point_of_contact(request_id):
"""
Remove the current point of contact from a given request
:param request_id: FOIL request ID
"""
point_of_contact = get_current_point_of_contact(request_id)
set_point_of_contact(request_id, point_of_contact, False)
create_object(
Events(
request_id,
current_user.guid,
current_user.auth_user_type,
event_type.REQ_POINT_OF_CONTACT_REMOVED,
previous_value={
"user_guid": point_of_contact.user_guid,
"auth_user_type": point_of_contact.auth_user_type,
"point_of_contact": "True"
},
new_value={
"user_guid": point_of_contact.user_guid,
"auth_user_type": point_of_contact.auth_user_type,
"point_of_contact": "False"
},
timestamp=datetime.utcnow(),
))
def _create_agency_user_requests(request_id, agency_admins, guid_for_event):
"""
Creates user_requests entries for agency administrators.
:param request_id: Request being created
:param agency_users: List of Users
:param guid_for_event: guid used to create request events
:return:
"""
for admin in agency_admins:
user_request = UserRequests(
user_guid=admin.guid,
request_user_type=user_type_request.AGENCY,
request_id=request_id,
permissions=Roles.query.filter_by(
name=role.AGENCY_ADMIN).first().permissions)
create_object(user_request)
create_object(
Events(request_id,
guid_for_event,
event_type.USER_ADDED,
previous_value=None,
new_value=user_request.val_for_events,
response_id=None,
timestamp=datetime.utcnow()))
def create_document(uploader_id, file_title, file_name, document_type,
file_type, file_path, division):
"""
Util function to create a Document object and 'document_uploaded' Event
:param uploader_id: Id of the user who uploaded the file
:param file_title: Human readable version of the file name
:param file_name: Actual file name
:param document_type: Category of document
:param file_type: Extension of the file
:param file_path: Full path of where the file is saved on the server
:param division: Division that the file relates to
"""
# Create Document object
document = Documents(uploader_id=uploader_id,
file_title=file_title,
file_name=file_name,
document_type=document_type,
file_type=file_type,
file_path=file_path,
division=division)
create_object(document)
# Create document_uploaded Event
event = Events(document_id=document.id,
user_id=uploader_id,
type="document_uploaded",
previous_value={},
new_value=document.val_for_events)
create_object(event)
def setUp(self):
self.user = Users
self.password = self.user.hash_password('password')
self.new_user = self.user('John', 'Doe', '*****@*****.**',
self.password)
self.new_event = Events("Barbecue party", "nairobi", "Food",
"12/12/2017", 'frank')
def post(self, user_id):
"""Handle POST request for this view. Url ---> /api/events"""
user = User.query.filter_by(id=user_id).first() # get user details
if user.email_confirmed is not True:
response = {
"message":
'Your Must Confirm your Email Address in-order to create an event'
}
return make_response(jsonify(response)), 401
args = {}
event_models = [
'title', 'location', 'time', 'date', 'description', 'image_url',
'event_category'
]
for event_res in event_models:
var = str(request.data.get(event_res, '').capitalize())
var = var.strip(' \t\n\r')
if not var:
response = {"message": '{} missing'.format(event_res)}
return make_response(jsonify(response)), 401
args.update({event_res: var})
if Events.query.filter_by(title=args['title']).first():
response = {"message": 'Event title exists. Choose another one'}
return make_response(jsonify(response)), 401
event = Events(**args, created_by=user_id)
event.save()
response = jsonify({
'id': event.id,
'title': event.title,
'location': event.location,
'time': event.time,
'date': event.date,
'description': event.description,
'image_url': event.image_url,
'created_by': user.name,
'event_category': event.event_category,
})
return make_response(response), 201
def reset_db():
flash(
"Resetting database: deleting old data and repopulating with dummy data"
)
meta = db.metadata
for table in reversed(meta.sorted_tables):
print('Clear table {}'.format(table))
db.session.execute(table.delete())
db.session.commit()
artist1 = Artist(name="Drake", description="Soon to be added")
artist2 = Artist(name='Kendrick Lamar', description="Added after Drake")
venue1 = Venues(location='Baltimore Soundstage, Maryland',
date='01/24/2018')
venue2 = Venues(location='The 20th Century Theater, Ohio',
date='04/28/2018')
venue3 = Venues(location='The New Parish, California', date='04/29/2018')
event1 = Events(name='Aubrey & The Three Migos ',
price='$350',
venue_id=1,
event_date=datetime.utcnow())
event2 = Events(name='Leeds Festival 2018',
price='$170',
venue_id=2,
event_date=datetime.utcnow())
a2e = ArtistToEvent(Artist_id=1, Event_id=1)
a2e1 = ArtistToEvent(Artist_id=2, Event_id=2)
db.session.add(artist1)
db.session.add(artist2)
db.session.add(venue1)
db.session.add(venue2)
db.session.add(venue3)
db.session.add(event1)
db.session.add(event2)
db.session.add(a2e)
db.session.add(a2e1)
db.session.commit()
return redirect(url_for('index'))
def addEvent():
body = json.loads(request.data.decode())
try:
if "type" in body:
event = Events(subject=body['subject'],
type=body.get('type'),
message=body['message'])
else:
event = Events(subject=body['subject'], message=body['message'])
db.session.add(event)
db.session.commit()
except Exception as e:
print('DB Error: ', e)
rsp = Response("Error on event registration",
status=401,
content_type="text/plain")
return rsp
print(event)
rsp = Response("Event registered", status=200, content_type="text/plain")
return rsp
def create_request_info_event(request_id, type_, previous_value, new_value):
"""
Create and store events object for updating the request information into database.
:param request_id: request ID
:param type_: event type
:param previous_value: previous value
:param new_value: new value
"""
event = Events(request_id=request_id,
user_guid=current_user.guid,
type_=type_,
previous_value=previous_value,
new_value=new_value)
create_object(event)
def create_event():
""" Event create view """
form = CreateEventForm(request.form)
if request.method == 'POST' and form.validate():
try:
format_string = '%Y-%m-%dT%H:%M'
name = str(request.form['name'])
year = int(request.form['year'])
semester = Semester(int(request.form['semester']))
specialslot = int(request.form['special_slots'])
specialslotname = str(request.form['special_slots_name'])
specialslotdescription = str(
request.form['special_slots_description'])
timestamp = datetime.now()
opensignuptimestamp = datetime.strptime(
str(request.form['open_signup_timestamp']), format_string)
closesignuptimestamp = datetime.strptime(
str(request.form['close_signup_timestamp']), format_string)
place = str(request.form['place'])
participationfee = str(request.form['participation_fee'])
signup_open = False
active = False
except Exception as e:
print(e)
return render_template('error.html',
message=str(
request.form['opensignuptimestamp']))
try:
event = Events(name=name,
year=year,
special_slots=specialslot,
special_slots_name=specialslotname,
special_slots_description=specialslotdescription,
place=place,
semester=semester,
creation_timestamp=timestamp,
signup_open=signup_open,
active=active,
participation_fee=participationfee,
open_signup_timestamp=opensignuptimestamp,
close_signup_timestamp=closesignuptimestamp)
db.session.add(event)
db.session.commit()
except Exception as e:
print(e)
return render_template('error.html')
return redirect(url_for('admin'))
return render_template('create_event.html', form=form)
def search():
"""search events given an event name"""
#get the name given
name = request.args.get('q')
#get the given page and number of events or set them to default
page = request.args.get("page", default=1, type=int)
per_page = request.args.get("limit", default=15, type=int)
if name:
found_events = Events.get_events_by_name(name, page, per_page)
if found_events.items:
event_list = make_event_list(found_events.items)
return jsonify(event_list), 200
return jsonify({"message" : "there are no more events matching the given name"}), 404
return jsonify({"message" : "can not search events, provide event name"}), 400
def import_test_data(db):
with open('./test_data.csv', newline='') as csvfile:
spamreader = csv.reader(csvfile, delimiter=';')
header = True
for row in spamreader:
if header:
header = False
continue
new_event = Events(asin=row[0],
brand=row[1],
id=row[2],
source=row[3],
stars=int(row[4]),
timestamp=datetime.datetime.fromtimestamp(
int(row[5])))
db.session.add(new_event)
db.session.commit()
def create_news(author, title, content, tags):
"""
Util function for creating a News object. Function will take parameters passed in from the form
and create a News along with the event object.
"""
news = News(author=author, title=title, content=content, tags=tags)
create_object(news)
# Create news_created Event
event = Events(post_id=news.id,
user_id=author,
type="news_created",
previous_value={},
new_value=news.val_for_events)
create_object(event)
return news.id
def create_user_request_event(events_type, user_request, old_permissions=None):
"""
Create an Event for the addition, removal, or updating of a UserRequest
"""
if old_permissions is not None:
previous_value = {"permissions": old_permissions}
else:
previous_value = None
create_object(
Events(
user_request.request_id,
current_user.guid,
current_user.auth_user_type,
events_type,
previous_value=previous_value,
new_value=user_request.val_for_events,
timestamp=datetime.utcnow(),
))
def create_auth_event(auth_event_type: str, user_guid: str, new_value: dict):
"""
Create and store event object for given response.
Args:
auth_event_type (str): one of app.constants.event_type
user_guid (Users): Users object performing the authentication event
new_value (dict): Value to be stored in events table
"""
event = Events(request_id=None,
user_guid=user_guid,
type_=auth_event_type,
timestamp=datetime.utcnow(),
response_id=None,
previous_value=None,
new_value=new_value)
# store event object
create_object(event)
def post(self):
current_user = get_jwt_identity()
data = request.get_json()
if not data:
return invalid_data, 400
name = data["name"]
desc = data["description"]
location = data["location"]
date = data["event_date"]
event = Events.query.filter_by(name=name, user_id=current_user).first()
if event:
return {"error": "event exists"}, 409
post_event = Events(name=name,
desc=desc,
location=location,
event_date=date,
owner=current_user)
db.session.add(post_event)
db.session.commit()
return {"message": "{} has been added".format(name)}, 201
def edit_events():
form = EventsForm()
events = Events.query.all()
if form.validate_on_submit():
event = Events(Events_title=form.Events_title.data, Events_time=form.Events_time.data,
Events_city=form.Events_city.data,
Events_country=form.Events_country.data, Events_intro=form.Events_intro.data)
db.session.add(event)
db.session.commit()
flash(_('Added'))
return redirect(url_for('main.edit_events'))
if request.method == 'POST':
del_form = request.form
for ID in del_form.to_dict():
record_id = ID
del_event = Events.query.filter_by(id=record_id).first()
db.session.delete(del_event)
db.session.commit()
flash(_('Deleted'))
return redirect(url_for('main.edit_events'))
return render_template("edit_database/EditEvents.html", form=form, events=events)
def rsvp(event_id):
"""register a user to an event"""
event = Events.get_event_by_id(event_id)
if event:
if request.method == 'POST':
res = event.add_rsvp(g.user)
if res == "rsvp success":
return jsonify({"message" : "rsvp success, see you then"}), 201
return jsonify({"message" : "already registered for this event"}), 302
rsvps = event.rsvps.all()
if rsvps:
rsvp_list = []
for user in rsvps:
rsvp= {
"username" : user.username,
"email" : user.email
}
rsvp_list.append(rsvp)
return jsonify(rsvp_list), 200
return jsonify({"message" : "no users have responded to this event yet"}),200
return jsonify({"message" : "event does not exist"}), 404
def patch(agency_ein):
"""
Only accessible by Super Users
Currently only changes:
is_active
"""
if not current_user.is_anonymous and current_user.is_super:
is_active = request.form.get('is_active')
if is_active is not None and Agencies.query.filter_by(
ein=agency_ein).first() is not None:
update_object({'is_active': eval_request_bool(is_active)},
Agencies, agency_ein)
create_object(
Events(request_id=None,
user_guid=current_user.guid,
auth_user_type=current_user.auth_user_type,
type_=AGENCY_ACTIVATED,
new_value={"ein": agency_ein},
timestamp=datetime.utcnow()))
return '', 200
return '', 400
return '', 403
def create_meeting_notes(meeting_date, meeting_location, meeting_leader,
meeting_note_taker, start_time, end_time, attendees,
next_meeting_date, next_meeting_leader,
next_meeting_note_taker, meeting_type, division,
author, title, content, tags):
"""
Util function for creating a MeetingNotes object. Function will take parameters passed in from the form
and create a meeting notes along with the event object.
"""
meeting_notes = MeetingNotes(
meeting_date=meeting_date,
meeting_location=meeting_location,
meeting_leader=meeting_leader,
meeting_note_taker=meeting_note_taker,
start_time=start_time,
end_time=end_time,
attendees=attendees,
next_meeting_date=next_meeting_date or None,
next_meeting_leader=next_meeting_leader or None,
next_meeting_note_taker=next_meeting_note_taker or None,
meeting_type=meeting_type,
division=division,
author=author,
title=title,
content=content,
tags=tags)
create_object(meeting_notes)
# Create meeting_notes_created Event
event = Events(post_id=meeting_notes.id,
user_id=author,
type="meeting_notes_created",
previous_value={},
new_value=meeting_notes.val_for_events)
create_object(event)
return meeting_notes.id
