def delete_event():
""" Delete the event of the group
:param room_id: the room_id of the group
"""
incoming = request.get_json()
Event.delete_event_with_room_id(incoming['room_id'])
return jsonify(results = incoming['room_id'])
def get_events_rsvp(sel):
serialized = []
if sel == 'false':
#returns all the events that the current user has not RSVP to
subquery = EventRSVP.query.with_entities(
EventRSVP.event_id).filter_by(user_id=current_identity.id)
events = db.session.query(Event).filter(~Event.id.in_(subquery)).all()
serialized = [Event.serialize(e) for e in events]
else:
#returns all the events that the current user has RSVPed to, grouped by organization
events_and_status = db.session.query(Event, Event.org_id, EventRSVP.status).outerjoin(EventRSVP) \
.filter(EventRSVP.user_id.is_(current_identity.id)) \
.order_by(Event.event_start.desc()).all()
orgs = db.session.query(Organization).outerjoin(Event).outerjoin(EventRSVP) \
.filter(EventRSVP.user_id.is_(current_identity.id)).all()
serialized = [{
"title":
item.name,
"events":
[(Event.serialize(event), get_rsvp_status_string(rsvp_status))
for (event, org_id, rsvp_status) in events_and_status
if org_id is item.id]
} for item in orgs]
return jsonify(message=serialized), 200
def get_org_events(id):
serialized = []
org_name = Organization.query.get(id).name
#events rsvp with status
events_and_status = db.session.query(Event, EventRSVP.status).filter_by(org_id=id).outerjoin(EventRSVP) \
.filter(EventRSVP.user_id.is_(current_identity.id)) \
.order_by(Event.event_start.desc()).all()
#events not rsvped to
events_rsvp = EventRSVP.query.with_entities(
EventRSVP.event_id).filter_by(user_id=current_identity.id).subquery()
events_not_rsvp = db.session.query(Event).filter(~Event.id.in_(events_rsvp)).filter_by(org_id=id)\
.order_by(Event.event_start.desc()).all()
events_serialized = [(Event.serialize(event),
get_rsvp_status_string(rsvp_status))
for (event, rsvp_status) in events_and_status]
[
events_serialized.append((Event.serialize(event), ""))
for event in events_not_rsvp
]
serialized = [{"title": org_name, "events": events_serialized}]
return jsonify(message=serialized), 200
def create_event():
request_data = request.get_json()
eventTags = ''.join(request_data["eventTags"].split()) + "#"
dateFormat = '%Y-%m-%dT%H:%M:%S'
eventStart = datetime.strptime(request_data["eventStartTime"][:-5],
dateFormat) - timedelta(hours=7)
eventEnd = datetime.strptime(request_data["eventEndTime"][:-5],
dateFormat) - timedelta(hours=7)
data = Event(name=request_data["eventTitle"],
description=request_data["eventDescription"],
location=request_data["eventLocation"],
event_start=eventStart,
event_end=eventEnd,
members_only=request_data["eventMembersOnly"],
max_participants=request_data["maxParticipants"],
image=request_data["eventImage"],
tags=eventTags)
org_name = request_data["callOutTitle"]
data.organization = Organization.query.filter_by(name=org_name).first()
data.creator = current_identity
try:
db.session.add(data)
db.session.commit()
except:
db.session.rollback()
return jsonify(message="successful event creation")
def write_to_events(action, objtype, objid, user=None):
if user:
event = Event(user.id, action, objtype, objid)
else:
event = Event(current_user.id, action, objtype, objid)
event.time = sydney_timezone_now()
db.session.add(event)
db.session.commit()
return event.id
def new_event():
form = EventForm()
if form.validate_on_submit():
print(form.youtube.data)
url = form.youtube.data.replace("watch?v=", "embed/")
if form.youtube.data == "":
url = None
if form.picture.data:
image_file = save_picture(form.picture.data)
if not form.picture.data:
image_file = ""
event = Event(event_name=form.title.data,
event_time=form.time.data,
location=form.location.data,
event_date=form.event_date.data,
last_registration=form.last_registration.data,
max_participants=form.max_participants.data)
db.session.add(event)
db.session.flush()
post = Post(title=form.title.data,
content=form.content.data,
youtube=url,
author=current_user,
image_file=image_file,
event_id=event.id)
db.session.add(post)
db.session.commit()
return redirect(url_for('posts.home'))
user_info = User_info.query.filter_by(id=current_user.id).first()
return render_template('new_event.html', form=form, user_info=user_info)
def create_event():
""" Create an event with name, location, start and end time and description
:param room_id: the room_id of the group
:param event_name: the name of the event
:param location: the location of the event
:param start_time: start date and time of the event
:param end_time: end date and time of the event
:param description: the description of the event
"""
incoming = request.get_json()
try:
start_time = incoming['start_time'][:-1].replace('T', ' ')
except:
start_time = None
try:
end_time = incoming['end_time'][:-1].replace('T', ' ')
except:
end_time = None
event = Event(
room_id = incoming['room_id'],
name = incoming['event_name'],
location = incoming['location'],
start_time = start_time,
end_time = end_time,
description = incoming['description']
)
db.session.add(event)
db.session.commit()
return jsonify(results = event.room_id)
def upload():
if request.method == 'GET':
return redirect(url_for('home'))
file = request.files['image']
EventNameFile = request.form['EventName']
EventDateFile = request.form['EventDate']
EventTimeFile = request.form['EventTime']
EventLocationFile = request.form['EventLocation']
EventDescriptionFile = request.form['EventDescription']
if not file:
flash("No file")
return render_template('index.html')
if not EventNameFile:
flash("Incorrect Name")
return render_template('index.html')
if not EventDateFile:
flash("Incorrect Date")
return render_template('index.html')
if not EventTimeFile:
flash("Incorrect Time")
return render_template('index.html')
if not EventLocationFile:
flash("Incorrect Location")
return render_template('index.html')
if not EventDescriptionFile:
flash("Incorrect Description")
return render_template('index.html')
f = os.path.join(app.config['UPLOAD_FOLDER'], file.filename)
file.save(f)
print(EventNameFile)
print(EventDateFile)
print(EventTimeFile)
print(EventLocationFile)
print(EventDescriptionFile)
try:
geolocator = Nominatim(user_agent="cleanup-meetup")
location = geolocator.geocode(EventLocationFile)
print((location.latitude, location.longitude))
locLat = truncate(location.latitude)
locLng = truncate(location.longitude)
except:
flash("Please enter a valid address!")
return render_template('index.html')
#FOR DEMOING PURPOSES!!!!!!!!
userID = "UserID1"
e = Event(name=EventNameFile,
lat=locLat,
lng=locLng,
confirmed_users=userID,
event_date=EventDateFile,
event_creator=userID,
fileLocation=file.filename,
address=EventLocationFile,
description=EventDescriptionFile,
time=EventTimeFile)
db.session.add(e)
db.session.commit()
return render_template('index.html')
def get_all_events():
serialized = []
try:
events = Event.query.all()
serialized = [Event.serialize(item) for item in events]
except:
db.session.rollback()
return jsonify(message=serialized), 200
def get_event():
""" Get the event information of the group
:param room_id: the room_id of the group
"""
incoming = request.get_json()
event = Event.get_event_with_room_id(incoming['room_id'])
if event:
results = {'event_name': event.name,
'location': event.location, 'start_time': event.start_time,
'end_time': event.end_time, 'description': event.description}
else:
results = {'event_name': "", 'location': "",
'start_time': "", 'end_time': "", 'description': ""}
return jsonify(results = results)
def get_events(sel):
serialized = []
if sel == 'true':
#gets all the events for the orgs you are an admin of
orgs = current_identity.organizations_as_admin
else:
#gets all the events for the orgs you are a member of
orgs = current_identity.organizations_as_member
serialized = [{
"title": item.name,
"admin": True,
"events": [Event.serialize(i) for i in item.events]
} for item in orgs]
return jsonify(message=serialized), 200
def get_events_filtered():
serialized = []
tag = request.args.get("filter")
#default when there is no filter, returns all the events you have not rsvp to
if tag == "":
return get_events_rsvp("false")
try:
subquery = EventRSVP.query.with_entities(
EventRSVP.event_id).filter_by(user_id=current_identity.id)
events = db.session.query(Event).filter(~Event.id.in_(subquery)) \
.filter((Event.tags.like("%#" + tag + "#%")) | (Event.name.like("%" + tag + "%"))).all()
serialized = [Event.serialize(item) for item in events]
except:
db.session.rollback()
return jsonify(message=serialized), 200
def sportradar_insert_game(game_data):
for game in game_data['games']:
name = '{0} {1} at {2} {3}'.format(
game['away']['market'], game['away']['name'],
game['home']['market'], game['home']['name'])
start_date = date_from_string(game['scheduled'])
try:
event = Event(name, start_date, game['id'])
db.session.add(event)
db.session.commit()
for adapter in adapters:
instance = adapter()
name = instance.assign_name(game)
outcome = Outcome(event.id, name, datetime.datetime.now(),
start_date, True, adapter.type_id)
db.session.add(outcome)
except InvalidRequestError:
continue # already exists
db.session.commit()
def create_event(cls, session, name, ts=dt.now(), msg="msg"):
event = Event(name=name, ts=ts, msg=(f"{name}_{msg}"))
session.add(event)
session.commit()
return event
def make_event(self, data, **kwargs):
return Event(**data)
def order_coffee(slackclient, user, channel, match):
"""Handle adding coffee to existing orders.
Args:
slackclient: the slackclient.SlackClient object for the current
connection to Slack.
user: the slackclient.User object for the user who send the
message to us.
channel: the slackclient.Channel object for the channel the
message was received on.
match: the object returned by re.match (an _sre.SRE_Match object).
"""
logger = logging.getLogger('order_coffee')
logger.info('Matches: %s', pprint.pformat(match.groupdict()))
runid = match.groupdict().get('runid', None)
run = None
if runid and runid.isdigit():
run = Run.query.filter_by(id=int(runid)).first()
if not run:
# Pick a run
runs = Run.query.filter_by(is_open=True).order_by('time').all()
if len(runs) > 1:
def resolve_run_feedback():
channel.send_message(
'More than one open run, please specify by adding run=<id> on the end.'
)
list_runs(slackclient, user, channel, match=None)
return (False, resolve_run_feedback)
if len(runs) == 0:
def resolve_closed_feedback():
channel.send_message('No open runs')
return (False, resolve_closed_feedback)
run = runs[0]
# Create the coffee
c = coffeespecs.Coffee(match.groupdict().get('order', None))
validation_errors = list(c.validation_errors())
if validation_errors:
def resolve_validation_feedback():
channel.send_message(
'That coffee is not valid missing the following specs: {}. Got: {}'
.format(
', '.join(spec.name for spec in validation_errors),
c,
))
return (False, resolve_validation_feedback)
coffee = Coffee(c, 0, run.id)
# Find the user that requested this
dbuser = utils.get_or_create_user(user.id, TEAM_ID, user.name)
logger.info('User: %s', dbuser)
# Put it all together
coffee.person = dbuser.id
db.session.add(coffee)
db.session.commit()
events.coffee_added(run.id, coffee.id)
# Write the event
event = Event(coffee.person, "created", "coffee", coffee.id)
event.time = sydney_timezone_now()
db.session.add(event)
db.session.commit()
logger.info('Parsed coffee: %s', coffee)
runuser = User.query.filter_by(id=run.person).first()
if runuser.slack_user_id:
mention_runner = '<@{}>'.format(runuser.slack_user_id)
else:
mention_runner = runuser.name
channel.send_message('That\'s a {} for {} (added to {}\'s run.)'.format(
coffee.pretty_print(), mention(user), mention_runner))
return (True, None)
