def move_team(self, request, *args, **kwargs):
user_id = request.data.get('user_id')
current_team_id = Utils.convert_to_int(
request.data.get('current_team_id'))
new_team_id = Utils.convert_to_int(request.data.get('new_team_id'))
TeamService.move_team(user_id, current_team_id, new_team_id)
return Response({'Success': True})
def to_representation(self, instance):
ret = super().to_representation(instance)
profile_id = ret.get('profile')
profile = Profile.objects.get(id=profile_id)
ret.update(
name=profile.name,
leave_day_left=DateService.get_leave_day_statistic(profile_id).get('leave_day_left'),
team='No team'
)
if profile.teams:
team = Team.objects.filter(id=int(profile.teams.split(',')[0])).first()
if team:
ret.update(team=team.team_name)
start_hour = Workday.DEFAULT_START_HOUR
end_hour = Workday.DEFAULT_END_HOUR
if ret.get('start_hour') and ret.get('end_hour'):
start_hour_json = Utils.safe_jsonloads(ret.get('start_hour'))
end_hour_json = Utils.safe_jsonloads(ret.get('end_hour'))
if start_hour_json and end_hour_json:
start_hour = f"{start_hour_json.get('hour')}:{start_hour_json.get('min')}"
end_hour = f"{end_hour_json.get('hour')}:{end_hour_json.get('min')}"
ret.update(
start_hour=start_hour,
end_hour=end_hour
)
return ret
def get_leave_day_statistic(cls, profile_id):
now = datetime.datetime.now()
user_profile = Profile.objects.get(id=profile_id)
last_year_queryset = Date.objects.filter(date__year=now.year - 1)
last_remote, last_half_leave, last_full_leave = cls.get_leave_remote(
last_year_queryset, profile_id)
last_total_leave = last_full_leave + last_half_leave * 0.5
first_half_queryset = Date.objects.filter(date__year=now.year,
date__month__lt=7)
first_half_remote, first_half_half_leave, first_half_full_leave = cls.get_leave_remote(
first_half_queryset, profile_id)
first_half_total_leave = first_half_full_leave + first_half_half_leave * 0.5
last_leave_day_left = cls.get_leave_day_in_year(
last_total_leave, user_profile.join_date)
if user_profile.join_date.month < 7:
last_leave_day_left -= 1
if now.month < 7:
if last_leave_day_left > 0:
current_leave_day_left = cls.get_leave_day_in_year(
first_half_total_leave, user_profile.join_date)
leave_day_left = f"{last_leave_day_left} days last year, {current_leave_day_left} days this year"
else:
current_leave_day_left = cls.get_leave_day_in_year(
first_half_total_leave,
user_profile.join_date) + last_leave_day_left
leave_day_left = f"{current_leave_day_left} days"
total_leave = Utils.convert_to_int(first_half_total_leave)
total_remote = first_half_remote
else:
second_half_queryset = Date.objects.filter(date__year=now.year,
date__month__gte=7)
second_half_remote, second_half_half_leave, second_half_full_leave = cls.get_leave_remote(
second_half_queryset, profile_id)
second_half_total_leave = second_half_full_leave + second_half_half_leave * 0.5
if last_leave_day_left > 0:
current_leave_day_left = cls.get_leave_day_in_year(
second_half_total_leave, user_profile.join_date)
else:
current_leave_day_left = cls.get_leave_day_in_year(
second_half_total_leave,
user_profile.join_date) + last_leave_day_left
leave_day_left = f"{current_leave_day_left} days"
total_leave = Utils.convert_to_int(first_half_total_leave +
second_half_total_leave)
total_remote = first_half_remote + second_half_remote
return {
'id': profile_id,
'name': user_profile.name,
'leave_day_number': f'{total_leave} leave, {total_remote} remote',
'leave_day_left': leave_day_left
}
def create_lunch_current_month(self, request, *args, **kwargs):
current_month, current_year = Utils.get_current_date()
LunchService.create_lunch_days(
current_month,
current_year,
lunch_users=Profile.objects.filter(lunch=True))
return Response({'success': True})
def get_list(cls):
response = []
now = datetime.datetime.now()
next_year, next_month = Utils.nextmonth(year=now.year, month=now.month)
for date in Lunchdate.objects.filter(
date__month__in=[now.month, next_month]):
queryset = Lunch.objects.filter(date=date.id).annotate(
name=F('profile__name')).values('profile', 'name')
profiles = Profile.objects.filter(user__active=True).exclude(
id__in=[data.get('profile')
for data in queryset]).values('id', 'name')
response.extend(({
'start': date.date,
'end': date.date,
'title': 'Eat',
'class': 'eat',
'content': str(queryset.count()),
'reason': queryset
}, {
'start': date.date,
'end': date.date,
'title': 'No eat',
'class': 'no',
'content': str(profiles.count()),
'reason': profiles
}))
return response
def retrieve(self, request, *args, **kwargs):
profile_id = Utils.convert_to_int(kwargs.get('pk'))
queryset = ProposeLeave.objects.filter(
start__gte=datetime.datetime.now(), profile_id=profile_id)
if request.query_params.get('history'):
queryset = ProposeLeave.objects.filter(
start__lt=datetime.datetime.now(), profile_id=profile_id)
data = self.get_data(queryset, request.query_params.get('history'))
return Response(data)
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
profile_id = Utils.convert_to_int(request.data.get('profile'))
start_date = request.data.get('start')
end_date = request.data.get('end')
ProposeLeaveService.approve_finalize(profile_id, start_date, end_date)
return Response(serializer.data)
def update_lunch(cls, profile):
now = datetime.datetime.now()
Lunch.objects.filter(profile_id=profile.id,
date__date__gt=datetime.datetime.now()).delete()
cls.create_lunch_days(year=now.year,
month=now.month,
lunch_users=[profile])
year, next_month = Utils.nextmonth(year=now.year, month=now.month)
cls.create_lunch_days(year=year,
month=next_month,
lunch_users=[profile])
def list(self, request, *args, **kwargs):
query_name = self.request.query_params.get('name', None)
if query_name:
queryset = self.queryset.filter(
profile__name__istartswith=query_name)
else:
queryset = self.filter_queryset(self.get_queryset())
active = self.request.query_params.get('active')
if active:
queryset = queryset.filter(
Q(active=1 and Utils.convert_to_int(active)))
page = self.paginate_queryset(queryset)
data = self.get_serializer(page, many=True).data
return self.get_paginated_response(data)
def lunch_creation():
current_month, current_year = Utils.get_current_date()
year, next_month = Utils.nextmonth(year=current_year, month=current_month)
LunchService.create_lunch_days(next_month, year, lunch_users=Profile.objects.filter(lunch=True))
def retrieve_date_statistic(self, request, *args, **kwargs):
profile_id = Utils.convert_to_int(kwargs.get('pk'))
return Response(DateService.get_leave_day_statistic(profile_id))
def get_leave_day_in_year(cls, total_leave, join_date):
leave_day_left = Utils.convert_to_int(
12 - total_leave +
relativedelta(datetime.datetime.now(), join_date).years)
return leave_day_left