def put(self, request, pk, format=None):
event = self.get_object(pk)
serializer = EventSerializer(event, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
event_id = self.kwargs.get('event_id', None)
if not event_id:
return ApiResponse.bad_request('Event ID missing')
try:
event = Event.objects.get(id=event_id)
except:
event = None
if not event:
return ApiResponse.bad_request("Event Doesn't exist")
if event.is_public:
data = EventSerializer(event).data
return Response(data)
elif event.host.id == request.user.id:
data = EventSerializer(event).data
return Response(data)
elif Invitation.objects.filter(user_id=request.user.id,
event_id=event.id):
data = EventSerializer(event).data
return Response(data)
else:
return ApiResponse.forbidden(
"You are not allow to view this information")
def patch(self, request, format=None):
if request.user.is_authenticated() and is_manager(request):
shift_id = request.POST.get('shift_id')
shift = Shift.objects.get(id=shift_id)
shift_data = {'manager_approved': True}
shift_serializer = ShiftSerializer(shift,
data=shift_data,
partial=True)
event = Event.objects.get(id=shift.event_id)
current_emp_id = event.employee_id
event_data = {'employee_id': shift.interested_emp_id}
event_serializer = EventSerializer(event,
data=event_data,
partial=True)
stat_giver = Stat.objects.get(user_id=current_emp_id)
stat_taker = Stat.objects.get(user_id=shift.interested_emp_id)
stat_giver_serializer = StatSerializer(
stat_giver, data={}, context={'situation': 'giver'})
stat_taker_serializer = StatSerializer(
stat_taker, data={}, context={'situation': 'taker'})
if stat_giver_serializer.is_valid(
) and stat_taker_serializer.is_valid():
stat_giver_serializer.save()
stat_taker_serializer.save()
if shift_serializer.is_valid() and event_serializer.is_valid():
shift_serializer.save()
event_serializer.save()
return Response(shift_serializer.data)
return Response(shift_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_update_contact(self):
url = reverse('event-detail', args=[self.event.id])
request = self.factory.get(url)
data = EventSerializer(self.event, context={'request': request}).data
data.update({'name': 'Update Name'})
request = self.factory.put(url, data, format='json')
force_authenticate(request, user=self.user)
view = EventsViewSet.as_view({'put': 'update'})
response = view(request, pk=data['id'])
self.assertEqual(Event.objects.get(id=data['id']).name, 'Update Name')
self.assertEqual(response.status_code, status.HTTP_302_FOUND)
def new(request):
parser_class = (FileUploadParser, )
if request.method == 'POST':
serializer = EventSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
public_events = Event.objects.filter(is_public=True,
date__gt=datetime.datetime.now())
data = {}
public_events = EventSerializer(public_events, many=True).data
data['public_events'] = public_events
private_event_invitations = Event.objects.filter(
is_public=False, invitation__user=request.user)
private_event_invitations = EventSerializer(private_event_invitations,
many=True).data
data['private_event_invitations'] = private_event_invitations
return Response(data)
def post(self, request, format=None):
serializer = EventSerializer(data=request.data,
context={'request': request})
employee_id = request.data.get('employee_id')
employee_profile = Profile.objects.get(user_id=employee_id)
profile_serializer = ProfileSerializer(employee_profile)
if serializer.is_valid():
serializer.save()
add_event_data = serializer.data
add_event_data.update({'employee_profile': profile_serializer.data})
return Response(add_event_data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
date_selected = request.GET.get('start_date')
start_date = parse(date_selected)
end_date = start_date + timedelta(hours=23, minutes=59, seconds=59)
user_id = request.user.id
user_manager = is_manager(request)
if user_manager:
events = Event.objects.filter(start_date__range=(start_date, end_date),
manager_id=user_id)
else:
events = Event.objects.filter(start_date__range=(start_date, end_date),
employee_id=user_id)
serializer = EventSerializer(events, many=True)
employees = events.values('employee_id')
employee_profiles = Profile.objects.filter(user_id__in=employees)
for event in serializer.data:
event_employee = next((e for e in employee_profiles if e.user_id == event.get('employee_id')), None)
event_employee = ProfileSerializer(event_employee)
event.update({'employee_profile': event_employee.data})
return Response(serializer.data)
class CrossSearchTagSerializer(serializers.ModelSerializer):
in_posts = PostSerializer(many=True, read_only=True)
in_events = EventSerializer(many=True, read_only=True)
class Meta:
model = Tag
fields = ['name', 'in_events', 'in_posts']
def deregister_event(self, request, **kwargs):
student = request.user.student
event = Event.objects.get(id=kwargs["pk"])
deregistration = Registration.objects.get(event=event, student=student)
deregistration.delete()
serializer = EventSerializer(event)
return Response(serializer.data)
def get_events(request):
if request.method == 'GET':
event = Event.objects.all()
serializer = EventSerializer(event, many=True)
return Response(serializer.data)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def unbookmark_event(self, request, **kwargs):
student = request.user.student
event = Event.objects.get(id=kwargs["pk"])
unbookmark = Bookmark.objects.get(event=event, student=student)
unbookmark.delete()
serializer = EventSerializer(event)
return Response(serializer.data)
def edit(request, event_id):
parser_class = (FileUploadParser, )
try:
event = Event.objects.get(id=event_id)
except Event.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'PATCH':
serializer = EventSerializer(event, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def findEventsByCityAndType(request, city=None, type=None):
if type:
events = Event.objects.filter(city=city) # , type=type)
else:
print(city)
events = Event.objects.filter(city=city)
serializer = EventSerializer(events, many=True)
return Response(serializer.data)
def bookmarked_events(self, request, **kwargs):
student = request.user.student
bookmarks = Bookmark.objects.filter(student=student)
events = []
for bookmark in bookmarks:
events.append(bookmark.event)
serializer = EventSerializer(events, many=True)
return Response(serializer.data)
def attend_event(self, request, **kwargs):
student = request.user.student
event = Event.objects.get(id=kwargs["pk"])
registration = Registration.objects.filter(event=event,
student=student)
#registration.attended = True
registration.update(attended=True)
serializer = EventSerializer(event)
return Response(serializer.data)
def bookmark_event(self, request, **kwargs):
student = request.user.student
event = Event.objects.get(id=kwargs["pk"])
bookmark, bookmarked = Bookmark.objects.get_or_create(event=event,
student=student)
serializer = EventSerializer(event)
if bookmarked:
return Response(serializer.data)
else:
return Response(bookmarked)
def register_event(self, request, **kwargs):
student = request.user.student
event = Event.objects.get(id=kwargs["pk"])
registration, registered = Registration.objects.get_or_create(
event=event, student=student)
serializer = EventSerializer(event)
if registered:
return Response(serializer.data)
else:
return Response(registered)
def get_event(request, event_id):
try:
event = Event.objects.get(id=event_id)
except Event.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = EventSerializer(event)
return Response(serializer.data)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
if request.user.userprofile is None:
return Response({'events': 'there is no userprofile'},
status=status.HTTP_404_NOT_FOUND)
events = Event.objects.filter(organizer_id=request.user.userprofile.id)
if not events:
return Response({'events': 'No Events are in the database'},
status=status.HTTP_200_OK)
events = EventSerializer(events, many=True)
return Response({'events': events.data}, status=status.HTTP_200_OK)
def test_retrieve_events(self):
"""Test retrieving list of events"""
sample_event()
sample_event()
res = self.client.get(EVENTS_URL)
events = Event.objects.all().order_by('-name')
serializers = EventSerializer(events, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializers.data)
def get(self, request, event_date, name):
event_date = datetime.strptime(event_date, "%Y-%m-%d").date()
events = Event.objects.filter(name=name, event_date=event_date)
if not events:
return Response({'reason': "there is no event with the name:"\
f"{name} and the date {str(event_date)} "},
status=status.HTTP_404_NOT_FOUND)
event_serializer = EventSerializer(events[0])
return Response({'event': event_serializer.data},
status=status.HTTP_200_OK)
def retrieve(self, request, pk=None):
try:
queryset_organisation = Organisation.objects.get(pk=pk)
except Organisation.DoesNotExist:
raise Http404
queryset_event = Event.objects.filter(organisation=pk)
serialized_data_events = EventSerializer(queryset_event, many=True)
serialized_data_organisation = OrganisationSerializer(
queryset_organisation)
data = {**serialized_data_organisation.data}
data['events'] = serialized_data_events.data
return Response(data, status=status.HTTP_200_OK)
def test_retrieve_event_list(self):
"""test retrieve event"""
Event.objects.create(state=Event.EventState.CREATED, title="test name")
Event.objects.create(state=Event.EventState.CREATED,
title="Atest name")
res = self.client.get(EVENT_URL)
lst = Event.objects.all().order_by("-title")
serializer = EventSerializer(lst, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data["items"], serializer.data)
def get(self, request, format=None):
selected_date = request.GET.get('selected_date')
selected_date = parse(selected_date)
user_id = request.user.id
profile = Profile.objects.get(user_id=user_id)
position_id = profile.position_id
response = {'week_hours': 0,
'week_salary': 0,
'month_hours': 0,
'month_salary': 0,
'hourly_salary': 0}
if not position_id:
return Response(response)
today = datetime.today()
events_week = get_week_events(today, user_id)
events_month = get_month_events(selected_date, user_id)
position = Position.objects.get(id=position_id)
hourly_salary = position.salary
week_serializer = EventSerializer(events_week, many=True)
month_serializer = EventSerializer(events_month, many=True)
week_hours, week_salary = get_total_salary(week_serializer, hourly_salary)
month_hours, month_salary = get_total_salary(month_serializer, hourly_salary)
response = {'week_hours': week_hours,
'week_salary': week_salary,
'month_hours': month_hours,
'month_salary': month_salary,
'hourly_salary': hourly_salary}
return Response(response)
def get(self, request, format=None):
date_selected = request.GET.get('month_date')
date_selected = parse(date_selected)
if date_selected.hour != 0:
offset = timedelta(hours=date_selected.hour)
else:
offset = timedelta(hours=0)
month_selected = date_selected.month
year_selected = date_selected.year
[month_start, month_end] = calendar.monthrange(year_selected,
month_selected)
start_date = datetime(year_selected, month_selected, 1) + offset
end_date = (datetime(year_selected, month_selected, month_end) +
timedelta(hours=24) + offset)
user_id = request.user.id
user_manager = is_manager(request)
if user_manager:
events = Event.objects.filter(start_date__range=(start_date, end_date),
manager_id=user_id)
else:
events = Event.objects.filter(start_date__range=(start_date, end_date),
employee_id=user_id)
serializer = EventSerializer(events, many=True)
employees = events.values('employee_id')
employee_profiles = Profile.objects.filter(user_id__in=employees)
events_list = [[] for x in range(month_end + 1)]
for event in serializer.data:
if parse(event.get('start_date')).month != month_selected:
day = month_end
else:
day = (parse(event.get('start_date')) - offset).day
event_employee = next((e for e in employee_profiles if e.user_id == event.get('employee_id')), None)
event_employee = ProfileSerializer(event_employee)
event.update({'employee_profile': event_employee.data})
events_list[day].append(event)
return Response(events_list)
def create(self, request):
"""create"""
serializer = CreateEventSerializer(data=request.data, many=False)
serializer.is_valid(raise_exception=True)
event = self.model.objects.create(
name=serializer.data['name'],
created_by=serializer.data['login']['username'],
date=serializer.data['date'],
url=serializer.data['url'],
)
Participant.objects.create(
event=event,
username=serializer.data['login']['username'],
status=Participant.STATUS_YES
)
return Response(EventSerializer(event).data)
def indexView(request):
yesterday = datetime.today() - timedelta(days=1)
if request.user.is_authenticated:
#Show all events to club members
events_obj = Event.objects.exclude(date_time__lte=yesterday)
else:
#Show events with poster, form_link, message to general public
events_obj = Event.objects.exclude(
Q(date_time__lte=yesterday) | Q(poster='') | Q(form_link='')
| Q(publicity_message=''))
events_data = EventSerializer(
events_obj,
many=True,
fields=['name', 'date_time', 'poster', 'sigs', 'venue']).data
return Response(events_data)
def post(self, request, *args, **kwargs):
try:
name = request.data.get('name', '')
host = request.user
date = request.data.get('date', '')
duration = request.data.get('duration', 0)
is_public = request.data.get('is_public', True)
capacity = request.data.get('capacity', 0)
obj = Event.objects.create(name=name,
host=host,
date=date,
duration=duration,
is_public=is_public,
capacity=capacity)
obj.save()
data = EventSerializer(obj).data
return Response(data)
except Exception as e:
return ApiResponse.bad_request(
"Unable to add new event, something went wrong! Maybe Use YYYY-MM-DD HH:MM:SS date format"
)
def get(self, request, format=None):
week_monday = request.GET.get('week_monday')
week_monday = parse(week_monday)
if week_monday.hour != 0:
offset = timedelta(hours=week_monday.hour, seconds=1)
else:
offset = timedelta(hours=0)
start_date = datetime(week_monday.year, week_monday.month, week_monday.day)
end_date = start_date + timedelta(days=7)
user_id = request.user.id
user_manager = is_manager(request)
if user_manager:
events = Event.objects.filter(start_date__range=(start_date, end_date),
manager_id=user_id).order_by('start_date')
else:
events = Event.objects.filter(start_date__range=(start_date, end_date),
employee_id=user_id).order_by('start_date')
serializer = EventSerializer(events, many=True)
employees = events.values('employee_id')
employee_profiles = Profile.objects.filter(user_id__in=employees)
events_list = [[] for x in range(7)]
for event in serializer.data:
weekday = (parse(event.get('start_date')) - offset).weekday()
event_employee = next((e for e in employee_profiles if e.user_id == event.get('employee_id')), None)
event_employee = ProfileSerializer(event_employee)
event.update({'employee_profile': event_employee.data})
events_list[weekday].append(event)
return Response(events_list)
