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 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 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 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 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_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, 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 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 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 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))
