def test_create_event_model(self):
"""Test creating an event with the proper data"""
self.assertEqual(Event.objects(creator=self.USER).count(), 0)
e = self.make_event()
e.save()
self.assertEqual(Event.objects(creator=self.USER).count(), 1)
self.assertEqual(Event.objects().get(creator=self.USER), e)
def recurring_event(slug, index):
"""View a specific instance of a recurring event.
**Route:** ``/events/<slug>/<index>``
**Methods:** ``GET``
:param str slug: The unique slug ID for the post.
:param int index: The instance of the event to fetch.
"""
if Event.objects(published=True, slug=slug).count() == 0:
abort(404) # Either invalid event ID or duplicate IDs.
event = Event.objects(published=True, slug=slug)[0]
if not event.is_recurring or not event.parent_series:
return redirect(url_for('.event', slug=slug))
if len(event.parent_series.events) <= index:
abort(404)
event = event.parent_series.events[index]
return render_template('events/event.html',
event=event,
now=now,
upcoming_events=_upcoming_events_triple(event))
def new(request):
selected_players = None
if request.method == 'POST':
selected_players = Player.objects.filter(pk__in=request.POST.getlist('players'))
if selected_players.count() == 4:
event = Event()
event.save()
for player in selected_players:
EventResult(player=player, event=event).save()
request.session['event_pk'] = event.pk
return redirect("race-start")
else:
messages.error(request, 'Please select exactly 4 players')
# Order player list by race_count
player_list = Player.objects.order_by('-race_count').all()
if not selected_players:
# Auto select most fanatic players
selected_players = player_list[:4]
return render(request, 'new.html', { 'player_list': player_list, 'selected_players': selected_players })
def event(slug):
"""View a specific non-recurring event, or the next upcoming instance of
a recurring event.
**Route:** ``/events/<slug>``
**Methods:** ``GET``
:param str slug: The unique slug ID for the post.
"""
if Event.objects(published=True, slug=slug).count() == 0:
abort(404) # Either invalid event ID or duplicate IDs.
event = Event.objects(published=True, slug=slug)[0]
if event.is_recurring:
upcoming_event_instances = (Event.objects(published=True,
start_date__gte=date.today(),
slug=slug)
.order_by('start_date'))
if upcoming_event_instances:
event = upcoming_event_instances[0]
else:
event = event.parent_series.events[-1]
return render_template('events/event.html',
event=event,
now=now,
upcoming_events=_upcoming_events_triple(event))
def events():
"""View the latest events.
**Route:** ``/events``
**Methods:** ``GET``
"""
today = date.today()
last_sunday = datetime.combine(today - timedelta(days=today.isoweekday()+7),
datetime.min.time())
next_sunday = datetime.combine(today + timedelta(days=7-today.isoweekday()),
datetime.min.time())
recent_and_upcoming = Event.objects(published=True,
start_date__gt=last_sunday).order_by('start_date',
'start_time')
recent_events = recent_and_upcoming.filter(end_date__lt=today)
events_this_week = recent_and_upcoming.filter(end_date__gte=today,
start_date__lt=next_sunday)
upcoming_events = recent_and_upcoming.filter(start_date__gt=next_sunday)[:4]
more_past_events = bool(Event.objects(published=True,
start_date__lte=last_sunday).count())
return render_template('events/events.html',
recent_events=recent_events,
events_this_week=events_this_week,
upcoming_events=upcoming_events,
more_past_events=more_past_events)
def create_single_event(cls, form, creator):
"""Creates a non-recurring Mongoengine and Google Calendar event from
form data.
:param form: The WTForms form.
:type form: :class:`CreateEventForm` or a subclass.
:param creator: The user that is currently logged in.
:type creator: :class:`~app.models.User`
:raises: :class:`GoogleCalendarAPIError` and it's subclasses
:returns: Response from the Google Calendar API.
:rtype: dict
"""
# Generate the event and date data
event_and_date_data = DataBuilder.event_and_date_data_from_form(
form,
creator=creator
)
event_and_date_data = cls._remove_none_fields(event_and_date_data)
event = Event(**event_and_date_data)
event.save()
# Return the Google Calendar response
return gcal_client.create_event(event)
def test_event_start_datetimes(self):
"""Test that when events are created with both start_date and
start_time, start_datetime() is their value combined.
"""
e = Event(title=self.TITLE, creator=self.USER,
start_date=self.START.date(),
start_time=self.START.time())
self.assertEqual(e.start_datetime(), self.START)
def test_event_end_datetimes(self):
"""Test that when events are created with both end_date and
end_time, end_datetime() is their value combined.
"""
e = Event(title=self.TITLE, creator=self.USER,
end_date=self.END.date(),
end_time=self.END.time())
self.assertEqual(e.end_datetime(), self.END)
def test_One(self):
tperformer = add_performer(bandname ="testband" )
tvenue = Venue(name ="Stereo")
tvenue.save()
my_datetime = timezone.make_aware(datetime.now(), timezone.get_current_timezone())
event_one = Event(time =my_datetime,media='https://www.youtube.com/watch?v=eh7lp9umG2I',venue=tvenue,performer=tperformer,no_tickets=-1)
event_one.save()
self.assertEqual((event_one.no_tickets >=0),True)
def addevent():
form = EventForm(request.form)
if request.method == 'POST' and form.validate():
event = Event(name=form.name.data,
intervalMinutes=form.intervalMinutes.data,
type=form.type.data, priority=form.priority.data)
event.save()
session['current_event'] = event
return redirect(url_for('views.selecttime'))
return render_template('addevent.html',session=session, form=form)
def add_event(request):
if request.method == 'POST':
event_form = AddEventForm(data=request.POST)
if event_form.is_valid():
event = Event()
event.name =event_form.cleaned_data['name']
dT = datetime.combine(event_form.cleaned_data['eventDate'], event_form.cleaned_data['eventTime'])
event.time = dT
event.no_tickets = event_form.cleaned_data['no_tickets']
event.price = event_form.cleaned_data['price']
vname = event_form.cleaned_data['venueName']
vAddress = event_form.cleaned_data['address']
vcontact = event_form.cleaned_data['contact']
vlocation =event_form.cleaned_data['location']
try:
v = Venue.objects.get(name=vname)
except:
v = Venue.objects.create(name=vname,address=vAddress,contact=vcontact,location=vlocation)
event.venue = v
get_performer = User.objects.get(username=request.user.username)
performer = Performer.objects.get(performer=get_performer)
event.performer = performer
event.save()
return HttpResponseRedirect('/app/performer_profile/')
else:
print event_form.errors
else:
event_form = AddEventForm()
return render(request, 'Gigstop/add_event.html', {'event_form': event_form})
def newevent():
form = CreateEventForm()
event=Event()
if form.validate_on_submit():
form.populate_obj(event)
event.image=event.image.replace("https://www.dropbox.com","https://dl.dropboxusercontent.com/")
db.session.add(event)
db.session.commit()
flash("Event created succesfully")
return redirect(url_for("admin.index"))
return render_template('newevent.html',form=form)
def test_event_start_datetimes_none_with_incomplete_data(self):
"""Test that when events are created without both of start_date and
start_time, start_datetime() returns None.
"""
e = Event(title=self.TITLE, creator=self.USER,
start_date=self.START.date())
self.assertIsNone(e.start_datetime())
f = Event(title=self.TITLE, creator=self.USER,
start_time=self.START.time())
self.assertIsNone(f.start_datetime())
def test_event_end_datetimes_none_with_incomplete_data(self):
"""Test that when events are created without both of end_date and
end_time, end_datetime() returns None.
"""
e = Event(title=self.TITLE, creator=self.USER,
end_date=self.END.date())
self.assertIsNone(e.end_datetime())
f = Event(title=self.TITLE, creator=self.USER,
end_time=self.END.time())
self.assertIsNone(f.end_datetime())
def create_single_event(klass, form, creator):
""""""
# Generate the event and date data
event_and_date_data = DataBuilder.event_and_date_data_from_form(form, creator=creator)
event_and_date_data = klass._remove_none_fields(event_and_date_data)
event = Event(**event_and_date_data)
event.save()
# Return the Google Calendar response
return gcal_client.create_event(event)
def _get_events_for_template(past, future):
"""Returns the events to insert in the events template. Returns four
groups of dates:
- ``past_events``: A list of dictionaries, where the dictionaries contain a
list of events for a week, and a label for the week.
- ``this_week``: A list of events happening this week.
- ``next_week``: A list of events happening next week.
- ``future_events``: A list of dictionaries similar to ``post_events``,
but for events happening in the future.
:returns: ``past_events``, ``this_week``, ``next_week``, ``future_events``
"""
today = date.today()
last_sunday = datetime.combine(
today - timedelta(days=(today.isoweekday() % 7)),
datetime.min.time()
)
next_sunday = last_sunday + timedelta(days=7)
following_sunday = last_sunday + timedelta(days=14)
this_week = (Event.objects(start_date__gte=last_sunday,
start_date__lt=next_sunday)
.order_by('start_date'))
next_week = (Event.objects(start_date__gte=next_sunday,
start_date__lt=following_sunday)
.order_by('start_date'))
past_events = []
future_events = []
for week_no in range(past):
ending_sunday = last_sunday - timedelta(days=7 * week_no)
starting_sunday = last_sunday - timedelta(days=7 * (week_no + 1))
week_name = _format_for_display(starting_sunday)
events = Event.objects(start_date__gte=starting_sunday,
start_date__lt=ending_sunday)
past_events.insert(0, {
'week_name': week_name,
'events': events,
})
for week_no in range(future):
starting_sunday = following_sunday + timedelta(days=7 * week_no)
ending_sunday = following_sunday + timedelta(days=7 * (week_no + 1))
week_name = _format_for_display(starting_sunday)
events = Event.objects(start_date__gte=starting_sunday,
start_date__lt=ending_sunday)
future_events.append({
'week_name': week_name,
'events': events,
})
return past_events, this_week, next_week, future_events
def test_delete_event_when_event_exists(self):
"""Test that when an event with id `_id` exists in the database and the
`/admin/events/delete/_id` route is POSTed to, it is deleted.
"""
e = self.make_event()
e.save()
print str(Event.objects())
self.assertEqual(Event.objects(creator=e.creator).count(), 1)
_id = e.id
resp = self.request_with_role('/admin/events/delete/%s' % _id, method="POST",
follow_redirects=True)
self.assertEqual(resp.status_code, 200)
self.assertEqual(Event.objects(creator=e.creator).count(), 0)
def _make_event(cls, e_data, d_data):
"""Create a new :class:`Event` object and save it to Mongoengine.
The event is created by unpacking non-None fields of ``e_data`` and
``d_data`` in the constructor for :class:`Event`.
:param dict e_data: The event data for this event.
:param dict d_data: The date data for this event.
"""
params = cls._remove_none_fields(dict(e_data.items() + d_data.items()))
event = Event(**params)
event.save()
return event
def delete(event_id):
""""""
object_id = ObjectId(event_id)
form = DeleteEventForm(request.form)
if Event.objects(id=object_id).count() == 1:
event = Event.objects().with_id(object_id)
try:
EventsHelper.delete_event(event, form)
except GoogleCalendarAPIError as e:
flash(e.message)
else:
flash('Invalid event id')
return redirect(url_for('.index'))
def scheduleCalReminderEvent(event, facebook_id):
print "scheduling cal reminder events"
print event
if 'location' not in event or event['location'] is None:
return False
today = datetime.today()
driving_time_in_sec = google_maps.driving_time_from_work(facebook_id, event['location'])['value']
walking_time_in_sec = google_maps.walking_time_from_work(facebook_id, event['location'])['value']
event_start_time = datetime.strptime(event['start_time'], "%I:%M %p")
event_start_time = datetime(today.year, today.month, today.day, event_start_time.hour, event_start_time.minute, 0)
driving_alert_time = event_start_time - timedelta(seconds=driving_time_in_sec)
walking_alert_time = event_start_time - timedelta(seconds=walking_time_in_sec)
driving_event = Event(facebook_id=facebook_id)
driving_event.trigger_enum = 5
driving_event.send_timestamp = driving_alert_time
driving_event.metadata_json = json.dumps(event)
walking_metadata = event.copy()
walking_metadata['drive_id'] = driving_event.id
walking_event = Event(facebook_id=facebook_id)
walking_event.trigger_enum = 4
walking_event.send_timestamp = walking_alert_time
walking_event.metadata_json = json.dumps(walking_metadata)
db.session.add(driving_event)
db.session.add(walking_event)
print "created driving and walking events!"
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
return False
return True
def db(app, request):
"""Session wide database connection."""
_db.init_app(app)
_db.create_all()
_db.session.commit()
Role.insert_roles()
Event.insert_event()
def teardown():
_db.session.close_all()
_db.drop_all()
request.addfinalizer(teardown)
return _db
def test_event_starting_on_midnight(self):
"""Test that events starting on midnight are properly formatted."""
from app.models import Event
start_date, start_time = date(2015, 04, 01), time(00)
end_date, end_time = date(2015, 04, 01), time(05, 30)
event = Event(start_date=start_date,
start_time=start_time,
end_date=end_date,
end_time=end_time,
**self.EVENT_KWARGS)
self.assertFalse(event.is_multiday())
self.assertEqual(event.human_readable_date(), 'Wednesday, April 1')
self.assertEqual(event.human_readable_time(), '12-5:30am')
def test_event_ending_on_midnight(self):
"""Test that events ending on midnight are properly formatted."""
from app.models import Event
start_date, start_time = date(2015, 03, 31), time(22)
end_date, end_time = date(2015, 04, 01), time(0)
event = Event(start_date=start_date,
start_time=start_time,
end_date=end_date,
end_time=end_time,
**self.EVENT_KWARGS)
self.assertFalse(event.is_multiday())
self.assertEqual(event.human_readable_date(), 'Tuesday, March 31')
self.assertEqual(event.human_readable_time(), '10pm-12am')
def test_human_readable_date(self):
"""Test that :func:`~app.models.Event.human_readable_date` properly
formats event dates into human readable date strings.
"""
from app.models import Event
for event_date, string in self.DATES:
event = Event(start_date=event_date,
start_time=None,
end_date=event_date,
end_time=None,
**self.EVENT_KWARGS)
msg = self.ERROR_MSG.format('human readable date',
string,
event.human_readable_date())
self.assertEqual(event.human_readable_date(), string, msg=msg)
def unpublish_event(self, stale_event):
"""Unpublish an event, moving it to the private calendar.
The first argument is called ``stale_event`` because it might have
outdated fields. The first thing we do is find a fresh event with it's
id in mongo.
:param stale_event: The event to publish
:type event: :class:`Event`
:raises: :class:`EventumError.GCalAPI.BadStatusLine`,
:class:`EventumError.GCalAPI.NotFound`,
:class:`EventumError.GCalAPI.Error`,
:class:`EventumError.GCalAPI.MissingID`
:returns: The Google Calendar API response.
:rtype: dict
"""
self.before_request()
# Freshen up stale_event
event = Event.objects().get(id=stale_event.id)
if event.published:
raise EventumError.GCalAPI.PublishFailed.PublishedTrue()
return self.move_event(event, from_id=self.public_calendar_id,
to_id=self.private_calendar_id)
def parse(msg):
msg = msg.split('::: A USER HAS ENTERED A REQUEST FOR A AUDIO VISUAL WORK ORDER ::::')
if len(msg) != 2:
# decline all messages that aren't work orders
logging.error("Message is not a valid work order. Disposing message.")
return
# split up the divider between info and equipment
vals = msg[1].split('================================================')
if len(vals) != 2: # decline all messages that aren't work orders
return
info = parse_info(vals[0], vals[1])
logging.info(info)
if info is None:
return
events_query = Event.query(
ndb.AND(Event.name == info['name'], Event.date == info['date']),
ndb.AND(Event.end_time == info['end_time'], Event.start_time == info['start_time'])
)
events_list = events_query.fetch()
if len(events_list) == 0:
Event(**info).put()
def update_event(self, stale_event, as_exception=False):
""""""
event = Event.objects().get(id=stale_event.id)
if not event.gcal_id:
self.create_event(stale_event)
raise GoogleCalendarAPIMissingID('Missing gplus_id. Successfully fell back to create.')
resource = None
resource = GoogleCalendarResourceBuilder.event_resource(event,
for_update=True)
calendar_id = self._calendar_id_for_event(event)
event_id_for_update = event.gcal_id
if as_exception:
instance = self._instance_resource_for_event_in_series(event)
instance.update(resource)
resource = instance
event_id_for_update = instance['id']
print '[GOOGLE_CALENDAR]: Update Event'
request = self.service.events().update(calendarId=calendar_id,
eventId=event_id_for_update,
body=resource)
try:
updated_event = self._execute_request(request)
except GoogleCalendarAPIErrorNotFound as e:
self.create_event(event)
print e.message
raise GoogleCalendarAPIErrorNotFound('Couldn\'t find event to update. '
'Successfully fell back to create.')
self._update_event_from_response(event, updated_event)
return updated_event
def test_human_readable_time(self):
"""Test that :func:`~app.models.Event.human_readable_time` properly
formats event times into human readable time strings.
"""
from app.models import Event
any_date = date(2015, 03, 31)
for start_time, end_time, string in self.TIMES:
event = Event(start_date=any_date,
start_time=start_time,
end_date=any_date,
end_time=end_time,
**self.EVENT_KWARGS)
msg = self.ERROR_MSG.format('human readable time',
string,
event.human_readable_time())
self.assertEqual(event.human_readable_time(), string, msg=msg)
def event_archive(index):
"""View old events.
**Route:** ``/events/<index>``
**Methods:** ``GET``
:param int index: The page to fetch
"""
if index <= 0:
return redirect(url_for('.events'))
# Get all events that occur on this page or on subsequent pages, and order
# them chronologically back in time
today = date.today()
events = (Event.objects(published=True, end_date__lt=today)
.order_by('-start_date')
.skip(NUM_PAST_EVENTS_FOR_FRONTPAGE +
(index - 1) * NUM_EVENTS_PER_PAGE))
# If there are no such events, redirect to the pevious page
if not events:
return redirect(url_for('.event_archive', index=index - 1))
# There is always a previous page, but there is only a next page if there
# are more events after this page
previous_index = index - 1
next_index = index + 1 if len(events) > NUM_EVENTS_PER_PAGE else None
# Use .limit() to only show NUM_EVENTS_PER_PAGE events per page
return render_template('events/archive.html',
events=events.limit(NUM_EVENTS_PER_PAGE),
previous_index=previous_index,
next_index=next_index)
def index():
"""View the ADI homepage.
**Route:** ``/``
**Methods:** ``GET``
"""
this_moment = datetime.now().time()
# cast date.today() to a datetime
today = datetime.combine(date.today(), datetime.min.time())
# Ending on a future date, or today at a future time. The events should be
# published, and should be chronological.
# We limit to four events, one large event and one set of three events.
events = (Event.objects(Q(end_date__gte=today))
# |
# Q(end_date=today, end_time__gt=this_moment)) #
.filter(published=True)
.order_by('start_date', 'start_time')
.limit(ONE_LARGE_AND_TRIPLE))
# sort published posts chronologically back in time
all_blog_posts = (BlogPost.objects(published=True)
.order_by('-date_published'))
latest_blog_post = all_blog_posts[0] if all_blog_posts else None
return render_template('index.html',
events=events,
blog_post=latest_blog_post)
def test_event_is_ongoing_expression(self):
"""Test to ensure that the is_ongoing() method
is functioning correctly within SQLAlchemy queries.
"""
role = TestModelFactory.create_role("Event Organizer")
user = TestModelFactory.create_user()
user.role = role
venue = TestModelFactory.create_venue()
event = TestModelFactory.create_event("Test Event", "live")
event.user = user
event.venue = venue
db.session.add_all([user, event])
db.session.commit()
query_obj = Event.query.filter(Event.is_ongoing() == True).first()
self.assertIsNotNone(query_obj)
self.assertEqual(event, query_obj)
def setUp(self):
db.create_all()
db.session.add(
User("Firstname", "Lastname", "*****@*****.**", "test123"))
db.session.add(User("Mock", "User", "*****@*****.**", "mock123"))
db.session.add(User("new", "User", "*****@*****.**", "new123"))
db.session.add(User("Competitor", "Jones", "*****@*****.**",
"comp123"))
user = User.query.filter_by(email="*****@*****.**").first()
user1 = User.query.filter_by(email="*****@*****.**").first()
user2 = User.query.filter_by(email="*****@*****.**").first()
db.session.add(
Competition(user.id, "Test name", "Test location",
datetime.date(2017, 12, 31)))
db.session.add(
Competition(20, "Cant view", "Cant view",
datetime.date(2017, 12, 31)))
comp = Competition.query.filter_by(comp_id=1).first()
comp.approved = True
comp20 = Competition.query.filter_by(organizer_id=20).first()
announce1 = Announcement(comp.comp_id, user.id, "Test announcement",
"Test body")
announce2 = Announcement(comp20.comp_id, 2, "Can i see this?", "maybe")
db.session.add(announce1)
db.session.add(announce2)
event1 = Event('Rubik\'s Cube', 'Round 1', datetime.time(11, 0, 0),
datetime.time(12, 0, 0))
db.session.add(event1)
comp.comp_events.append(event1)
comp.competitors.append(user)
comp.competitors.append(user1)
comp.competitors.append(user2)
register_user1 = EventUserLink(user=user1, event=event1)
register_user2 = EventUserLink(user=user2, event=event1)
db.session.add(register_user1)
db.session.add(register_user2)
register_user2.volunteer = True
register_user2.volunteer_role = 'Judge'
register_user1.staff = True
register_user1.staff_role = 'Scrambler'
db.session.commit()
def post(self):
"""
Creates new event
"""
data, errors = EventSchema().load(request.get_json())
logger.info("Creating new event, data: %s", request.get_json())
if errors:
logger.info("Cannot create event, data: %s", request.get_json())
return errors, 400
event = Event(name=data['name'],
start_time=data['start_time'])
for key, value in data.items():
setattr(event, key, value)
db.session.add(event)
db.session.commit()
logger.info("Event created, data: %s", request.get_json())
return
def createEvent():
if current_user.is_authenticated:
data = request.get_json()
event = Event(title=data['title'],
description=data['description'],
date=data['date'],
user_id=current_user.get_id())
if (event != None):
db.session.add(event)
db.session.commit()
return jsonify({"done": 'event created'})
else:
return jsonify({"err": 'invalid event'})
else:
return redirect(url_for('login'))
def setUp(self):
app.config['TESTING'] = True
app.config['WTF_CSRF_ENABLED'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'app.db')
self.app = app.test_client()
db.session.commit()
db.drop_all()
db.create_all()
admin = User(username="******", password_hash="admin2016",first_name="admin",last_name="admin2", email="*****@*****.**")
post1= Post(id="1", body="test", user_id="admin")
event1 = Event(name="Test", id="1")
db.session.add(admin)
db.session.add(post1)
db.session.add(event1)
db.session.commit()
def test_event_has_ended_expression(self):
"""Test to ensure the correct functionality of
the has_ended() method in a SQLAlchemy query.
"""
role = TestModelFactory.create_role("Event Organizer")
user = TestModelFactory.create_user()
user.role = role
venue = TestModelFactory.create_venue()
event = TestModelFactory.create_event("Test Event", "past")
event.user = user
event.venue = venue
db.session.add_all([user, event])
db.session.commit()
result = Event.query.filter(Event.has_ended() == True).first()
self.assertIsNotNone(result)
self.assertEqual(event, result)
def setUp(self):
self.app = myapp
self.app.config.update(
TESTING = True,
SQLALCHEMY_ECHO = False,
SQLALCHEMY_DATABASE_URI = 'sqlite://',
)
self.client = self.app.test_client()
# The cleanup and schema creation
db.session.close()
db.drop_all()
db.create_all()
# The test fixtures (Ideally this would sit under a separate fixtures modules)
testData = [
(
'Cricket',
'Australia Vs Ireland',
datetime(2018, 11, 23, 10, 10, 10),
[('Australia', 1.01), ('Ireland', 1.01)]
),
(
'Football',
'Spain Vs Germany',
datetime(2018, 11, 22, 10, 10, 10),
[('Spain', 1.01), ('Germany', 1.01)]
),
(
'Football',
'Portugal Vs Italy',
datetime(2018, 11, 21, 10, 10, 10),
[('Portugal', 1.01), ('Italy', 1.01)]
)
]
for sportName, eventName, eventTime, selections in testData:
sport = getOrCreate(db.session, Sport, name=sportName)
event = Event(
name=eventName,
startTime=eventTime,
sport=sport
)
market = Market(name='Winner', event=event)
for selName, odds in selections:
db.session.add(Selection(name=selName, odds=odds, market=market))
db.session.commit()
def new_event():
form = EditEventForm()
if form.validate_on_submit():
kwb_event = Event()
kwb_event.title = form.title.data
kwb_event.location = form.location.data
kwb_event.description = form.description.data
kwb_event.start = form.start.data
kwb_event.end = form.end.data
db.session.add(kwb_event)
db.session.commit()
flash('Your blog post has been created!')
return redirect(url_for('events'))
return render_template("create_event.html", form=form)
def add_change():
form = ChangeForm()
if form.validate_on_submit():
Event().create(
user_id=current_user.id,
child_id=current_user.children[0],
type='change',
started_at=str(form.started_at.data),
ended_at=str(form.started_at.data),
feed_type=None,
change_type=form.change_type.data,
amount=None,
unit=None,
side=None,
notes=form.notes.data)
flash('Change has been added', 'success')
return redirect(url_for('view_diary'))
return render_template('change.html', title='Add change', form=form)
def __call__(self, form, field):
"""Called internally by :mod:`wtforms` on validation of the field.
:param form: The parent form
:type form: :class:`Form`
:param field: The field to validate
:type field: :class:`Field`
:raises: :class:`wtforms.validators.ValidationError`
"""
from app.models import Event, EventSeries
# If we change the slug, make sure the new slug doesn't exist
if self.original.slug != field.data:
if EventSeries.objects(slug=field.data).count():
raise ValidationError(self.message)
if Event.objects(slug=field.data).count():
raise ValidationError(self.message)
def generate_events_email(emails_path):
connect('eventum')
today_weekday = datetime.date.today().weekday()
date_start = datetime.date.today() - datetime.timedelta(today_weekday + 1)
events = []
for each_event in Event.objects():
if date_start <= each_event.start_date <= date_start + datetime.timedelta(
7):
events.append(each_event)
env = Environment(loader=PackageLoader('app', 'templates'))
template = env.get_template('email/weekly.html')
print template.render(events=events)
def add_bottle():
form = BottleForm()
if form.validate_on_submit():
Event().create(
user_id=current_user.id,
child_id=current_user.children[0],
type='feed',
started_at=str(form.started_at.data),
ended_at=str(form.ended_at.data) if form.ended_at.data else None,
feed_type=form.feed_type.data,
change_type=None,
amount=float(form.amount.data),
unit=form.unit.data,
side=None,
notes=form.notes.data)
flash('Bottle feed has been added', 'success')
return redirect(url_for('view_diary'))
return render_template('bottle.html', title='Add bottle feed', form=form)
def get_event_messages(current_user, event_id):
skip = request.args.get('skip', 0, type=int)
count = request.args.get('count', None, type=int)
try:
int(event_id)
except ValueError:
return response('failed', 'Please provide a valid Event Id', 400)
user = User.get_by_id(current_user.id)
event = Event.get_by_id(event_id)
if not event:
abort(404)
messages, nex, previous, skip, total = paginate_messages(
skip, count, event, user)
return response_with_pagination_messages(get_message_json_list(messages),
previous, nex, skip, total)
def add_event(tournament, team, event_name, names):
user_ids = []
for i in names:
if i is None or i == '':
user_ids.append(None)
else:
firstname, lastname = i.lower().split()
u = User.query.filter_by(firstname=firstname,
lastname=lastname).first()
user_ids.append(u.id)
t = Tournament.query.filter_by(name=tournament, team=team).first()
event = Event(tournament_id=t.id,
event_name=event_name.strip(),
user1_id=user_ids[0],
user2_id=user_ids[1],
user3_id=user_ids[2])
db.session.add(event)
db.session.commit()
def newEvent(comp_id):
form = ScheduleForm()
comp = Competition.query.filter_by(comp_id=comp_id).first()
if request.method == 'POST':
if form.validate_on_submit():
newEvent = Event(form.event.data, form.event_round.data, form.start_time.data, form.end_time.data)
db.session.add(newEvent)
comp.comp_events.append(newEvent)
db.session.commit()
flash(form.event.data + " event created!")
return redirect(url_for('manage.schedule', comp_id=comp.comp_id))
else:
flash('Somethings not working!')
return render_template('newevent.html', form=form, comp=comp)
return render_template('newevent.html', form=form, comp=comp)
def test_event_start_datetimes_none_with_incomplete_data(self):
"""Test that when events are created without both of start_date and
start_time, start_datetime() returns None.
"""
e = Event(title=self.TITLE,
creator=self.USER,
start_date=self.START.date())
self.assertIsNone(e.start_datetime())
f = Event(title=self.TITLE,
creator=self.USER,
start_time=self.START.time())
self.assertIsNone(f.start_datetime())
def test_event_end_datetimes_none_with_incomplete_data(self):
"""Test that when events are created without both of end_date and
end_time, end_datetime() returns None.
"""
e = Event(title=self.TITLE,
creator=self.USER,
end_date=self.END.date())
self.assertIsNone(e.end_datetime())
f = Event(title=self.TITLE,
creator=self.USER,
end_time=self.END.time())
self.assertIsNone(f.end_datetime())
def put(self):
parser = reqparse.RequestParser()
parser.add_argument('img',
type=FileStorage,
location=['files', 'form'])
args = parser.parse_args()
img = args['img']
user = g.user
if user:
path = basedir + "/resources/" + current_app.config["PHOTO_DIR"]
tempFilename = secure_filename(
encrypt_filename(user.username + "upload"))
tempFilepath = path + "/uploadPhoto/" + tempFilename + current_app.config[
"PHOTO_FORMAT"]
args.img.save(tempFilepath)
originPhotoPath = path + "/systemPhoto/" + user.photoName + current_app.config[
"PHOTO_FORMAT"]
face = Facepp(key, secret)
res = face.FaceCompare(image_file1=tempFilepath,
image_file2=originPhotoPath)
if res.get('confidence'):
if res['confidence'] < current_app.config["CONFIDENCE"]:
status = 1
else:
status = 2
else:
status = 1
newEvent = Event(id=Event.query.with_entities(Event.id).count() +
1,
username=user.username,
uploadPhotoName=tempFilename,
status=status,
confidence=res.get('confidence'))
db.session.add(newEvent)
db.session.commit()
if status == 2:
user.lastStatus = status
return jsonify({
"code": 200,
"status": status,
"confidence": res['confidence']
})
else:
return jsonify({"code": 500})
def createNewEvent():
form = EventForm()
form.venueName.choices = [(venue.id, venue.name)
for venue in Venue.query.all()]
form.artists.choices = [(artist.id, artist.name)
for artist in Artist.query.all()]
if form.validate_on_submit():
flash('New event requested for Event {}'.format(form.eventName.data))
my_event = Event(name=form.eventName.data,
date=form.date.data,
venue_id=form.venueName.data)
for a in form.artists.data:
my_artist = Artist.query.filter_by(id=a).first()
db.session.add(ArtistToEvent(artist=my_artist, event=my_event))
db.session.add(my_event)
db.session.commit()
flash('New event created.')
return redirect(url_for('listOfArtists'))
return render_template('newEvent.html', title='newEvent', form=form)
def edit_event(request, eid=None):
instance = Event() if not eid else get_object_or_404(Event, pk=eid)
form = EventForm(request.POST or None, instance=instance)
form.fields['patient'].queryset = Patient.objects.newest(request.user)
form.fields['procedures'].queryset = Procedure.objects.newest(request.user)
if 'term' in request.GET:
pattern = request.GET.get('term')
medications = Event.objects.medication_list(pattern, request.user)
return JsonResponse(medications, safe=False)
if request.POST:
if 'delete' in request.POST:
Event.objects.delete(eid)
return HttpResponseRedirect(reverse('calendar'))
elif 'save' in request.POST and form.is_valid():
form.save()
return HttpResponseRedirect(reverse('calendar'))
return render(request, 'edit_form.html', {'form': form})
def add_events():
form = EventForm()
if form.validate_on_submit():
event = Event(title=form.title.data,
description=form.description.data,
start_date=form.start_date.data,
start_time=form.start_time.data,
end_date=form.end_date.data,
end_time=form.end_time.data,
address=form.address.data,
zipcode=form.zipcode.data,
category=form.category.data,
creater=current_user)
db.session.add(event)
current_user.subscribe(event)
db.session.commit()
flash('Your event has been added to the calendar')
return redirect(url_for('index'))
return render_template('add_events.html', title='Add Events', form=form)
def index():
"""The homepage of Eventum. Shows the latest blog posts and events.
**Route:** ``/admin/home``
**Methods:** ``GET``
"""
today = date.today()
last_sunday = datetime.combine(
today - timedelta(days=(today.isoweekday() % 7)), datetime.min.time())
next_sunday = last_sunday + timedelta(days=7)
this_week = Event.objects(
start_date__gt=last_sunday,
start_date__lt=next_sunday).order_by('start_date')
posts = BlogPost.objects().order_by('published', '-date_published')[:5]
return render_template("admin/home.html",
this_week=this_week,
recent_posts=posts)
def add_events(events):
for e in events:
path = e['thumbnail']['path']
if path == 'http://i.annihil.us/u/prod/marvel/i/mg/f/60/4c002e0305708.gif':
continue
if 'image_not_available' in path.split('/'):
continue
if not e['start']:
continue
path = path + '.' + e['thumbnail']['extension']
event = Event(e["id"], e["title"], e["description"], path,
e["start"][:4], "")
for c in e["characters"]["items"]:
char_id = int(c['resourceURI'].split('/')[-1])
character = Character.query.filter_by(id=char_id).first()
if character:
event.characters.append(character)
db.session.merge(event)
db.session.commit()
print("Added " + e["title"])
def modifyevent():
form = ModifyEventForm()
if form.validate_on_submit():
event_to_modify = Event.query.filter(
Event.id == form.id_event.data).first()
#control if it is allowed to delete the post
if str(event_to_modify.user_id) == str(current_user.get_id()):
db.session.delete(event_to_modify)
db.session.commit()
event = Event(name=form.name.data,
addr_1=form.addr_1.data,
location=form.location.data,
datetime_start=form.datetime_start.data,
user_id=current_user.get_id())
db.session.add(event)
db.session.commit()
flash('You have successfully modified the event!')
else:
flash('You can not modify events of other users!')
return render_template('modifyevent.html', title='Modify Event', form=form)
def create_new_event_id(start_at) -> str:
cycle_id = Cycle.query.filter(
and_(
start_at >= Cycle.start_at,
start_at < Cycle.end_at)).first().id
create_at = datetime.now()
notice_days = (start_at - create_at).days
new_event_id = Event(organised_by=current_user.id, created_at=create_at,
notice_days=notice_days,
notice_mult=notice_score(cycle_id, notice_days),
attendee_cnt=1,
attendee_mult=attendance_score(cycle_id, 1),
cycle_id=cycle_id)
db.session.add(new_event_id)
db.session.commit()
# TODO there has to be a neater way
event_id = db.session.query(Event.id).filter(
Event.organised_by == current_user.id).order_by(
desc(Event.created_at), desc(Event.id)).first()
return event_id
def activities():
if request.method == 'POST':
if request.form['activity_type'] == "Event":
event = Event(request.form['title'], request.form['slug'],
request.form['description'], request.form['body'])
db.session.add(event)
db.session.commit()
flash('Event Upload Successful!')
return redirect(url_for('general.events'))
elif request.form['activity_type'] == "Workshop":
workshop = Workshop(request.form['title'], request.form['slug'],
request.form['description'],
request.form['body'])
db.session.add(workshop)
db.session.commit()
flash('Workshop Upload Successful!')
return redirect(url_for('general.workshops'))
else:
flash("Activity type unknown!")
return html_minify(render_template('admin/activities.html'))
def new_event():
form = AddEventForm()
form.venue.choices = [(v.id, v.name) for v in Venue.query.all()]
form.artists.choices = [(a.id, a.name) for a in Artist.query.all()]
if form.validate_on_submit():
event = form.event.data
venue = form.venue.data
time = form.time.data
artists = form.artists.data
e1 = Event(name=event, time=time, venueID=venue)
db.session.add(e1)
db.session.commit()
for a in artists:
a2e = ArtistToEvent(artistID=a, eventID=e1.id)
db.session.add(a2e)
db.session.commit()
return redirect('/index')
return render_template('new_event.html', title='New Artist', form=form)
def create():
form = EventForm()
# If entered values are valid commit event to db
if form.validate_on_submit():
event = Event(title=form.title.data,
due_date=datetime.strptime(form.eventdatetime.data,
"%m/%d/%Y %I:%M %p"),
description=form.description.data,
user_id=current_user.id)
db.session.add(event)
db.session.commit()
flash("Your event has been created!", "success")
return redirect(url_for("overview"))
form.submit.label.text = 'Create'
return render_template("create.html",
title="Create Event",
form=form,
legend="Create Your Next Event!")
def index():
"""View the ADI homepage.
**Route:** ``/``
**Methods:** ``GET``
"""
all_events = (Event.objects(
Q(published=True, end_date__gt=date.today())
| Q(published=True,
end_date=date.today(),
end_time__gt=datetime.now().time())))
events = all_events.order_by('start_date', 'start_time')[:4]
all_blog_posts = BlogPost.objects(
published=True).order_by('-date_published')
blog_post = all_blog_posts[0] if all_blog_posts else None
return render_template('index.html', events=events, blog_post=blog_post)
def event():
event_form = EventForm()
if request.method == 'POST':
user_id = current_user.get_id()
datetime_start = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
datetime_end = datetime.datetime.strptime(request.form.get('datetime_end'), '%m/%d/%Y %I:%M %p').strftime('%Y-%m-%d %H:%M:%S')
topic = request.form.get('topic')
description = request.form.get('description')
event = Event(user_id=user_id,
datetime_start=datetime_start,
datetime_end=datetime_end,
topic=topic,
description=description
)
db.session.add(event)
db.session.commit()
return redirect('/')
return render_template('add_event.html', form=event_form)
