def setUpTestData(cls): Event.objects.bulk_create([ Event(description='Тестовое событие', date=datetime.datetime.now(pytz.utc)), Event(description='Второе тестовое событие', date=datetime.datetime.now(pytz.utc)), Event(description='Третье тестовое событие', date=datetime.datetime.now(pytz.utc)) ])
def setUp(cls): """ Data setup for the Subscription Unit test cases """ role = Role(role="subscriber") role.save() content = { "email": "*****@*****.**", "name": "user 12", "password": "******", "contact": "9999911111", "address": "Bangalore", "role": "subscriber", "organization": "Eventhigh" } url1 = reverse('registration') response = cls.client.post(url1, json.dumps(content), content_type='application/json') cls.user_id = response.data['data']['user']['user_id'] cls.token = response.data['data']['access'] cls.event_type = EventType(type="test") cls.event_type.save() cls.event = Event(name="test_event", type=cls.event_type, description="New Event", date="2020-04-02", time="12:38:00", location="karnal", subscription_fee=100, no_of_tickets=250, images="https://www.google.com/images", sold_tickets=0, external_links="google.com", event_created_by_id=cls.user_id) cls.event.save() cls.event_free = Event(name="test_event_free", type=cls.event_type, description="New Event", date="2020-04-02", time="12:38:00", location="karnal", subscription_fee=0, no_of_tickets=250, images="https://www.google.com/images", sold_tickets=0, external_links="google.com", event_created_by_id=cls.user_id) cls.event_free.save() cls.end_point = "/core/subscription/"
def test_has_stats(): event = Event() assert event.has_stats is False event = Event(applicants_count=10) assert event.has_stats is False event = Event(attendees_count=20) assert event.has_stats is False event = Event(attendees_count=20, applicants_count=40) assert event.has_stats is True
def test_has_stats(self): event = Event() self.assertFalse(event.has_stats) event = Event(applicants_count=10) self.assertFalse(event.has_stats) event = Event(attendees_count=20) self.assertFalse(event.has_stats) event = Event(attendees_count=20, applicants_count=40) self.assertTrue(event.has_stats)
def test_get(self): event1 = Event(name = 'FST Pre-Orientation', start_date_time = '2020-08-05T09:00:00Z', end_date_time = '2020-08-05T14:00:00Z', location = 'Faculty of Science and Technology') event1.save() event2 = Event(name = 'Fresher\'s Orientation', start_date_time = '2020-08-28T09:00:00Z', end_date_time = '2020-08-28T14:00:00Z', location = 'UWI, Mona') event2.save() response = self.client.get('/events/') self.assertEqual(response.status_code, 200) data = response.json() self.assertEqual(len(data), 2) expected_response = [{ 'id': event1.id, 'name': 'FST Pre-Orientation', 'start_date_time': '2020-08-05T09:00:00Z', 'end_date_time': '2020-08-05T14:00:00Z', 'location': 'Faculty of Science and Technology' }, { 'id': event2.id, 'name': 'Fresher\'s Orientation', 'start_date_time': '2020-08-28T09:00:00Z', 'end_date_time': '2020-08-28T14:00:00Z', 'location': 'UWI, Mona' }] self.assertEqual(data, expected_response)
def test_is_upcoming(): now = timezone.now() now_event = Event(date=ApproximateDate(now.year, now.month, now.day)) yesterday = now - timedelta(days=1) yesterday_event = Event( date=ApproximateDate(yesterday.year, yesterday.month, yesterday.day)) tomorrow = now + timedelta(days=1) tomorrow_event = Event( date=ApproximateDate(tomorrow.year, tomorrow.month, tomorrow.day)) assert now_event.is_upcoming() assert not yesterday_event.is_upcoming() assert tomorrow_event.is_upcoming()
def get_or_create_dummy(cls): from core.models import Event event, unused = Event.get_or_create_dummy() return cls.objects.get_or_create( event=event, name='Iso sali', )
def create(request): data = json.loads(request.body.decode('utf-8')) if request.method == 'POST': booking = Event(author=data['author'], title=data['title'], description=data['msg'], start=data['start'], end=data['end'], hex_color=data['hex_color']) booking.save() details = Event.objects.filter(author=data['author'], active=True).values() return JsonResponse(list(details), safe=False)
def get_or_create_dummy(cls): from core.models import Event from django.contrib.contenttypes.models import ContentType event, unused = Event.get_or_create_dummy() content_type = ContentType.objects.get_for_model(EmptySignupExtra) admin_group, unused = LabourEventMeta.get_or_create_group(event, 'admins') t = now() labour_event_meta, created = cls.objects.get_or_create( event=event, defaults=dict( admin_group=admin_group, signup_extra_content_type=content_type, registration_opens=t - timedelta(days=60), registration_closes=t + timedelta(days=60), work_begins=event.start_time - timedelta(days=1), work_ends=event.end_time + timedelta(days=1), contact_email='*****@*****.**', monitor_email='*****@*****.**', ) ) labour_event_meta.create_groups() return labour_event_meta, created
def create_event_viewset(request): getUserId = Token.objects.get( key=request.META.get("HTTP_AUTHORIZATION").split()[1] ).user_id getUserObj = User.objects.get(id=getUserId) ev = Event(owner=getUserObj) serializer = EventSerializer(ev, data=request.data) if serializer.is_valid(): today = datetime.now().date() date_str = request.data.get("date") format_str = "%Y-%m-%d" date_obj = datetime.strptime(date_str, format_str) if date_obj.date() < today: raise serializers.ValidationError( {"date": "Il n'est pas possible de créer un événement dans le passé"} ) crt_time = datetime.now().time() time_str = request.data.get("time") time_obj = datetime.strptime(time_str, "%H:%M") if time_obj.time() < crt_time and date_obj.date() <= today: raise serializers.ValidationError( { "time": "Il n'est pas possible de \ créer un événement dans le passé" } ) serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_or_create_dummies(cls): from core.models import Event event, unused = Event.get_or_create_dummy() jc1, unused = cls.objects.get_or_create(event=event, name="Dummy 1", slug='dummy-1') jc2, unused = cls.objects.get_or_create(event=event, name="Dummy 2", slug='dummy-2') return [jc1, jc2]
def get_or_create_dummy(cls): from django.contrib.contenttypes.models import ContentType from core.models import Event from .signup_extras import EmptySignupExtra event, unused = Event.get_or_create_dummy() content_type = ContentType.objects.get_for_model(EmptySignupExtra) admin_group, = LabourEventMeta.get_or_create_groups(event, ['admins']) t = now() labour_event_meta, created = cls.objects.get_or_create( event=event, defaults=dict( admin_group=admin_group, signup_extra_content_type=content_type, registration_opens=t - timedelta(days=60), registration_closes=t + timedelta(days=60), work_begins=event.start_time - timedelta(days=1), work_ends=event.end_time + timedelta(days=1), contact_email='*****@*****.**', monitor_email='*****@*****.**', ) ) labour_event_meta.create_groups() return labour_event_meta, created
def get_or_create_dummy(cls): from django.contrib.auth.models import Group from core.models import Event group, unused = Group.objects.get_or_create(name='Dummy ticket admin group') event, unused = Event.get_or_create_dummy() return cls.objects.get_or_create(event=event, defaults=dict(admin_group=group))
def get_or_create_dummy(cls): from core.models import Event event, unused = Event.get_or_create_dummy() admin_group, hosts_group = cls.get_or_create_groups(event, ["admins", "hosts"]) return cls.objects.get_or_create(event=event, defaults=dict(admin_group=admin_group, public=True))
def setUp(cls): """ Data set up for the unit test """ role = Role(role="organizer") role.save() user = User.objects.create_user(email="*****@*****.**", password="******") role_obj = Role.objects.get(role="organizer") user_profile_obj = UserProfile.objects.create( user=user, name="*****@*****.**", contact_number="9999911111", organization="organization", address="Bangalore", role=role_obj) user_profile_obj.save() data = dict(email="*****@*****.**", password="******") login_response = cls.client.post('/authentication/login', json.dumps(data), content_type='application/json') cls.user_id = login_response.data['data']['user']['user_id'] cls.token = login_response.data['data']['access'] cls.user = User.objects.get(id=cls.user_id) cls.event_type = EventType(type="test") cls.event_type.save() cls.event = Event(name="test_event", type=cls.event_type, description="New Event", date="2020-04-02", time="12:38:00", location="karnal", subscription_fee=500, no_of_tickets=250, images="https://www.google.com/images", sold_tickets=0, external_links="google.com", event_created_by_id=cls.user_id) cls.event.save()
def get_or_create_dummy(cls): from core.models import Event event, unused = Event.get_or_create_dummy() admin_group, organizer_group = cls.get_or_create_groups(event, ['admins', 'organizers']) return cls.objects.get_or_create(event=event, defaults=dict( admin_group=admin_group, organizer_group=organizer_group, ))
def get_or_create_dummies(cls): from core.models import Event event, unused = Event.get_or_create_dummy() limit_saturday, unused = cls.objects.get_or_create(event=event, description='Testing saturday', defaults=dict(limit=5000)) limit_sunday, unused = cls.objects.get_or_create(event=event, description='Testing sunday', defaults=dict(limit=5000)) return [limit_saturday, limit_sunday]
def save_event_to_db(event): '''The function to save single event into DB (table: core_event) ''' e = Event( categoryID = parse_category_id(event['category_id']), datePosted = parse_datetime(event['date_posted']), description = event['description'], distance = event['distance'], distanceUnits = event['distance_units'], endDate = parse_date(event['end_date']), endTime = parse_time(event['end_time']), geoCodingAmbig = event['geocoding_ambiguous'], geoCodingPrec = event['geocoding_precision'], eventID = event['id'], latitude = event['latitude'], longitude = event['longitude'], metroID = event['metro_id'], name = event['name'], numFutureEvents = event['num_future_events'], personal = event['personal'], photoURL = event['photo_url'], selfPromotion = event['selfpromotion'], startDate = parse_date(event['start_date']), startDateLastRendition = event['start_date_last_rendition'], startTime = parse_time(event['start_time']), ticketFree = parse_int(event['ticket_free']), ticketPrice = event['ticket_price'], ticketURL = event['ticket_url'], URL = event['url'], userID = event['user_id'], utcEnd = parse_datetime(event['utc_end']), utcStart = parse_datetime(event['utc_start']), venueAddr = event['venue_address'], venueCity = event['venue_city'], venueCountryCode = event['venue_country_code'], venueCountryID = event['venue_country_id'], venueCountryName = event['venue_country_name'], venueID = event['venue_id'], venueName = event['venue_name'], venueStateCode = event['venue_state_code'], venueStateID = event['venue_state_id'], venueStateName = event['venue_state_name'], venueZip = str(event['venue_zip']), watchListCount = event['watchlist_count']) e.save()
def setUp(cls): """ Data setup for Feedback Unit test cases """ role = Role(role="organizer") role.save() role2 = Role(role="subscriber") role2.save() user = User.objects.create_user(email="*****@*****.**", password="******") cls.role_obj = Role.objects.get(role="organizer") user_profile_obj = UserProfile.objects.create( user=user, name="*****@*****.**", contact_number="9999911111", organization="organization", address="Bangalore", role=cls.role_obj) user_profile_obj.save() content2 = { "email": "*****@*****.**", "name": "user 20", "password": "******", "contact": "9999911111", "address": "Bangalore", "role": "subscriber", "organization": "Eventhigh" } response = cls.client.post('/authentication/registration', json.dumps(content2), content_type='application/json') cls.user_id = response.data['data']['user']['user_id'] cls.token = response.data['data']['access'] cls.end_point = "/core/feedback/" cls.event_type = EventType(type="test") cls.event_type.save() cls.event = Event(name="test_event", type=cls.event_type, description="New Event", date="2020-04-02", time="12:38:00", location="karnal", subscription_fee=499, no_of_tickets=250, images="https://www.google.com/images", sold_tickets=0, external_links="google.com", event_created_by_id=User.objects.filter()[0].id) cls.event.save() cls.question = Question(question="Demo question1 ?") cls.question.save()
def test_event_filter(self): event, unused = Event.get_or_create_dummy() event2, unused = Event.get_or_create_dummy(name='Dummy event 2') kwargs = dict( channel='callback', callback_code=f'{__name__}:notification_callback', ) subscription_with_event_filter, unused = Subscription.get_or_create_dummy(event_filter=event, **kwargs) subscription_without_event_filter, unused = Subscription.get_or_create_dummy(event_filter=None, **kwargs) entry_type = subscription_with_event_filter.entry_type emit(entry_type, event=event) emit(entry_type, event=event2) assert len(notifications) == 3
def test_should_raise_validation_error_on_invalid_level(self): event = Event( title="Event", level="INVALID_LEVEL", description="django.core.exceptions.ValidationError", agent=self.agent, shelved=False, ) self.assertRaises(ValidationError, event.full_clean)
def test_get(self): event1 = Event( name='General Orientation for New Undergraduate Students', start_date_time='2020-08-28T09:00:00Z', end_date_time='2020-08-28T15:00:00Z', location='Online', poster_image='assets/general_orientation_poster.JPG') event1.save() event2 = Event(name='FST Virtual Orientation', start_date_time='2020-08-31T09:00:00Z', end_date_time='2020-09-04T17:00:00Z', location='Online', poster_image='assets/fst_orientation_poster.JPG') event2.save() response = self.client.get('/events/') self.assertEqual(response.status_code, 200) data = response.json() self.assertEqual(len(data), 2) expected_response = [{ 'id': event1.id, 'name': 'General Orientation for New Undergraduate Students', 'start_date_time': '2020-08-28T09:00:00Z', 'end_date_time': '2020-08-28T15:00:00Z', 'location': 'Online', 'poster_image': 'assets/general_orientation_poster.JPG' }, { 'id': event2.id, 'name': 'FST Virtual Orientation', 'start_date_time': '2020-08-31T09:00:00Z', 'end_date_time': '2020-09-04T17:00:00Z', 'location': 'Online', 'poster_image': 'assets/fst_orientation_poster.JPG' }] self.assertEqual(data, expected_response)
def _save(cls, event: Event, data: List[Tuple[AbstractUser, Dict[str, bool]]]): for user, is_member_by_app in data: for app_label in event.intra_event_meta.get_active_apps(): ensure_user_is_member_of_group( user, event.get_app_event_meta(app_label).admin_group, is_member_by_app[app_label]) CBACEntry.ensure_admin_group_privileges_for_event(event)
def get_or_create_dummy(cls): from core.models import Person, Event person, unused = Person.get_or_create_dummy() event, unused = Event.get_or_create_dummy() signup, created = Signup.objects.get_or_create(person=person, event=event) extra = signup.signup_extra extra.save() return signup, created
def setUp(self): app = get_application() self.client = Client(app, BaseResponse) self.test_values = { 'date': datetime.datetime(2016, 5, 20, 15, 0), 'title': 'THIS IS TITLE', 'description': 'THIS IS TITLE', } eve = Event( event_date=self.test_values['date'], title=self.test_values['title'], description=self.test_values['description'], ) eve.put() events = Event.all().fetch(100) self.assertEquals(len(events), 1) self.assertEquals(events[0].title, 'THIS IS TITLE') self.event_key = str(events[0].key())
def test_event_filter(self): event, unused = Event.get_or_create_dummy() event2, unused = Event.get_or_create_dummy(name='Dummy event 2') kwargs = dict( channel='callback', callback_code=f'{__name__}:notification_callback', ) subscription_with_event_filter, unused = Subscription.get_or_create_dummy( event_filter=event, **kwargs) subscription_without_event_filter, unused = Subscription.get_or_create_dummy( event_filter=None, **kwargs) entry_type = subscription_with_event_filter.entry_type emit(entry_type, event=event) emit(entry_type, event=event2) assert len(notifications) == 3
def get_or_create_dummy(cls, event=None): from django.contrib.auth.models import Group from core.models import Event if event is None: event, unused = Event.get_or_create_dummy() group, = PaymentsEventMeta.get_or_create_groups(event, ['admins']) return cls.objects.get_or_create(event=event, defaults=dict( EVENT_META_DEFAULTS, admin_group=group, ))
def get_or_create_dummy(cls): from core.models import Event from django.utils.timezone import now event, unused = Event.get_or_create_dummy() admin_group, hosts_group = cls.get_or_create_groups( event, ['admins', 'hosts']) return cls.objects.get_or_create(event=event, defaults=dict( admin_group=admin_group, public_from=now(), ))
def events(request): if request.user.is_anonymous(): return JsonResponse({'error': 'loggedOut'}) if request.method == 'POST': event_data = convert_dict_keys_deep(json.loads(request.body))['event'] if (not event_data['name'] or not event_data['date_from'] or not event_data['type'] or not event_data['color']): return JsonResponse({'error': 'badRequest'}) if (not event_data['id']): event = Event( name=event_data['name'], date_from=event_data['date_from'], date_to=event_data['date_to'], type=event_data['type'], color=event_data['color'], ) event.save() return JsonResponse({'event': serialize_event(event)}) events = [serialize_event(event) for event in Event.objects.order_by('date_from').all()] return JsonResponse({'events': events})
def get_or_create_dummy(cls, app_label='labour', name='Smallfolk', priority=0): from core.models import Event event, unused = Event.get_or_create_dummy() return PersonnelClass.objects.get_or_create( event=event, slug=slugify(name), app_label=app_label, defaults=dict( name=app_label, priority=priority, ) )
def create(self, event: Event): self.object = event wks = self.create_worksheet(title=str(self.object)[0:100], cols=self.columns) wks.adjust_column_width(1, None, 300) wks.adjust_column_width(2, None, 200) self.past_header(str(event.title), self.zeroCell) nextRow = self.current_row + 1 volonteers = Boec.objects.filter( event_participation__worth=1, event_participation__event=event ) organizers = Boec.objects.filter( event_participation__worth=2, event_participation__event=event ) participants = Boec.objects.filter( event_participation__worth=0, event_participation__event=event ) info_values = [ [["Штаб-организатор"], [event.shtab.title if event.shtab else "Без штаба"]], [["Волонтеров"], [volonteers.count()]], [["Организаторов"], [organizers.count()]], [["Блок"], [event.get_worth_display()]], ] self.past_info_cells(nextRow, info_values) nextRow = self.current_row + 2 if len(organizers) > 0: self.past_header("Организаторы", (nextRow, self.zeroCell[1])) nextRow = self.current_row + 1 self.past_boec(nextRow, organizers, Participant.WorthEnum.ORGANIZER) nextRow = self.current_row + 2 if len(volonteers) > 0: self.past_header("Волонтеры", (nextRow, self.zeroCell[1])) nextRow = self.current_row + 1 self.past_boec(nextRow, volonteers, Participant.WorthEnum.VOLONTEER) nextRow = self.current_row + 2 if len(participants) > 0: self.past_header("Участники", (nextRow, self.zeroCell[1])) nextRow = self.current_row + 1 self.past_boec(nextRow, participants, Participant.WorthEnum.DEFAULT) self.wks.rows = self.current_row url = self.get_wks_url() return url
def get_or_create_dummy(cls, app_label='labour', name='Smallfolk', priority=0): from core.models import Event event, unused = Event.get_or_create_dummy() return PersonnelClass.objects.get_or_create(event=event, slug=slugify(name), app_label=app_label, defaults=dict( name=app_label, priority=priority, ))
def get_or_create_dummy(cls): from core.models import Event from django.utils.timezone import now event, unused = Event.get_or_create_dummy() admin_group, hosts_group = cls.get_or_create_groups(event, ['admins', 'hosts']) return cls.objects.get_or_create( event=event, defaults=dict( admin_group=admin_group, public_from=now(), ) )
def quickCreate(name, sport, distance, city, date): """ example : quickCreate(name="Triathlon de Montélimar", sport="Triathlon", distance="XS", city="Montélimar", date="25/06/2015") """ s = Sport try: s = Sport.objects.get(name=sport) except Sport.DoesNotExist: print("Sport {0} does not exist".format(sport)) dc = DistanceCategory try: dc = DistanceCategory.objects.get(name=distance) except DistanceCategory.DoesNotExist: print("Distance {0} does not exist".format(distance)) e = Event(name=name, edition=1) e.save() c = Contact(name="Pierre Dupont") c.save() l = Location(country=Location.objects.all()[0].country, city=city) l.save() r = Race( sport=s, event=e, date=datetime.strptime(date, "%d/%m/%Y"), distance_cat=dc, price=40, contact=c, location=l, ) r.save() return r
def get_or_create_dummy(cls, event=None): from django.contrib.auth.models import Group from core.models import Event if event is None: event, unused = Event.get_or_create_dummy() group, unused = PaymentsEventMeta.get_or_create_group(event, 'admins') return cls.objects.get_or_create(event=event, defaults=dict( checkout_password='******', checkout_merchant='375917', checkout_delivery_date='20130914', admin_group=group, ))
def login(request): username = request.data.get("username") if username: username = username.lower() password = request.data.get("password") disableLogEvent = request.data.get("disableLogEvent") user = authenticate(username=username, password=password) if not user: #maybe email try: user2Try = User.objects.get(email__iexact=username) user = authenticate(username=user2Try.username, password=password) except Exception as ex: user2Try = None user = None if not user2Try: return Response({ "success": False, "error": "login.failed" }, status=HTTP_401_UNAUTHORIZED) try: profile = Profile.objects.get(user=user) if not profile.mobileVerified: return Response({ "success": False, "error": 'mobile.notverified', 'activationKey': profile.activationKey }) wallet = Wallet.objects.get(profile=profile) profileSerializer = ProfileSerializer(profile, context={'request': request}) except Profile.DoesNotExist: return Response({ "success": False, "error": "login.failed" }, status=HTTP_401_UNAUTHORIZED) token, _ = Token.objects.get_or_create(user=user) if not disableLogEvent: Event().createEvent('LOGIN', 'USERACTIVITY', '', profile, request) return Response({ "success": True, "token": token.key, 'profile': profileSerializer.data, })
def ical(request, event_key): event = Event.get(event_key) if event is None: return render_json_response({'error': '404 not found'}, mimetype='application/json', status=404) cal = icalendar.Calendar() eve = icalendar.Event() eve['dtstart'] = event.event_date.strftime('%Y%m%dT%H%M%S') eve['created'] = event.created_at.strftime('%Y%m%dT%H%M%S') eve['last-modified'] = event.updated_at.strftime('%Y%m%dT%H%M%S') eve['summary'] = event.title eve['description'] = event.description eve['event_key'] = event_key eve['updated_log'] = event.updated_log cal.add_component(eve) return Response(cal.to_ical(), status=200, mimetype="text/calendar", headers={'Content-Disposition': 'inline; filename=event.ics'})
def api_event_add(request): response = {} header = request.POST['header'] category = request.POST['category'] plan_id = request.POST['plan_id'] plan = Plan.objects.get(id=plan_id) new_event = Event() new_event.header = header new_event.category = category new_event.plan = plan new_event.order = len(plan.get_events()) new_event.save() response['event_id'] = new_event.id response['collaborator_id'] = request.user.id return response, 201
def get_or_create_dummy(cls, event=None, title="Dummy survey", **kwargs): if event is None: from core.models import Event event, unused = Event.get_or_create_dummy() slug = slugify(title) defaults = dict( event=event, title=title, model=dict(), ) defaults.update(kwargs) return cls.objects.get_or_create( slug=slug, defaults=defaults, )
def test_is_upcoming(): now = timezone.now() now_event = Event(date=ApproximateDate(now.year, now.month, now.day)) yesterday = now - timedelta(days=1) yesterday_event = Event(date=ApproximateDate( yesterday.year, yesterday.month, yesterday.day )) tomorrow = now + timedelta(days=1) tomorrow_event = Event(date=ApproximateDate( tomorrow.year, tomorrow.month, tomorrow.day )) assert now_event.is_upcoming() assert not yesterday_event.is_upcoming() assert tomorrow_event.is_upcoming()
def get_or_create_dummy(cls, accepted=False): from core.models import Person, Event from .job_category import JobCategory person, unused = Person.get_or_create_dummy() event, unused = Event.get_or_create_dummy() job_category, unused = JobCategory.get_or_create_dummy() signup, created = Signup.objects.get_or_create(person=person, event=event) if created: signup.job_categories.set([job_category]) if accepted: signup.job_categories_accepted.set(signup.job_categories.all()) signup.personnel_classes.add(signup.job_categories.first().personnel_classes.first()) signup.state = 'accepted' signup.save() signup.apply_state() return signup, created
def event_feed(request): try: theyear_themonth = request.args['month'].split('-') theyear = int(theyear_themonth[0]) themonth = int(theyear_themonth[1]) feed_title = 'Events of: %s %d' % (calendar.month_name[themonth], theyear) if themonth < 1 or themonth > 12: raise ValueError except: now = datetime.now() theyear = now.year themonth = now.month feed_title = _('Upcoming Event') first_day_of_themonth = datetime(theyear, themonth, 1) + timedelta(days=-1) three_month_after = add_months(first_day_of_themonth, 2) results = Event.all().filter(u'event_date >=', first_day_of_themonth).filter( u'event_date <', three_month_after).order('event_date').fetch(1000) events = [ {'date': r.event_date.strftime('%Y-%m-%d %H:%M'), 'title': r.title, 'description': r.description, 'key': str(r.key())} for r in results] return render_json_response({'events': events, 'title': feed_title}, mimetype='application/json')
def get_or_create_dummy(cls, accepted=False): from core.models import Person, Event from .job_category import JobCategory person, unused = Person.get_or_create_dummy() event, unused = Event.get_or_create_dummy() job_category, unused = JobCategory.get_or_create_dummy() signup, created = Signup.objects.get_or_create(person=person, event=event) if created: signup.job_categories.set([job_category]) if accepted: signup.job_categories_accepted.set(signup.job_categories.all()) signup.personnel_classes.add( signup.job_categories.first().personnel_classes.first()) signup.state = 'accepted' signup.save() signup.apply_state() return signup, created
def setUp(cls): role = Role(role="subscriber") role.save() content = { "email": "*****@*****.**", "name": "user test", "password": "******", "contact": "9999911111", "address": "Bangalore", "role": "subscriber", "organization": "Eventhigh" } response = cls.client.post('/authentication/registration', json.dumps(content), content_type='application/json') cls.user_id = response.data['data']['user']['user_id'] cls.token = response.data['data']['access'] cls.user = User.objects.get(id=cls.user_id) event_type = EventType(type="test") event_type.save() cls.event = Event(name="test_event", type=event_type, description="New Event", date="2020-04-02", time="12:38:00", location="karnal", subscription_fee=500, no_of_tickets=250, images="https://www.google.com/images", sold_tickets=0, external_links="google.com", event_created_by_id=cls.user_id) cls.event.save()
def __call__(self, *args): event = args[0] ev = Event(filename=os.path.join(event.path, event.name), type=event.mask) ev.save()
def get(self, request): user_id = request.user.id event = Event.first_or_create(user_id) return redirect(reverse('event_update', kwargs={'event_id': event.id}))
def checkout(request): if not request.user.is_authenticated(): return redirect('/user/login/') name = '' sumary = '' error_message = False total = 0 currency = 'USD' cart = [] if request.POST: name = request.POST['name'] sumary = request.POST['sumary'] if name and sumary: cart = request.session[settings.SHOPPING_CART_KEY] # Check client status client = Client.objects.filter(user__id = request.user.id) if client: # User is already registered as client client = client[0] else: client = Client(user=request.user, created=timezone.now()) client.save() # Create story and events story = Story( client = client, name = name, sumary = sumary, created = timezone.now() ) story.save() for ev in cart: place = Place.objects.get(pk=ev['place']) ev = complete_event(ev, place) event = Event( story = story, place = place, created = timezone.now(), start = ev['start'], end = ev['end'] ) event.save() del request.session[settings.SHOPPING_CART_KEY] return redirect('/story/' + str(story.id)) else: error_message = 'Some fields are required.' if settings.SHOPPING_CART_KEY in request.session: cart = request.session[settings.SHOPPING_CART_KEY] i = 0 for ev in cart: place = Place.objects.get(pk=ev['place']) ev['index'] = i ev = complete_event(ev, place) total += ev['price'] i = i+1 context = { 'name' : name, 'sumary' : sumary, 'total' : total, 'currency' : currency, 'cart' : cart, 'error_message' : error_message, 'user' : views.user_status(request), 'shopping_cart' : views.shopping_cart_status(request) } return render(request, 'story/checkout.html', context)
def get_or_create_dummy(cls): from core.models import Event event, unused = Event.get_or_create_dummy() group, = cls.get_or_create_groups(event, ['admins']) return cls.objects.get_or_create(event=event, defaults=dict(admin_group=group))