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)