def postWeek(inputYearWeek, gapWeek):
# inputYearWeek.astype("str")
# gapWeek.astype("int")
inputYearWeek=str(inputYearWeek)
gapWeek =int(gapWeek)
currYear = int(inputYearWeek[0:4])
currWeek = int(inputYearWeek[4:6])
maxWeek = Week.last_week_of_year(currYear).week
if(maxWeek <currWeek +gapWeek):
iterGap = gapWeek +currWeek - maxWeek
iterYear = currYear +1
iterWeek = Week.last_week_of_year(iterYear).week
while iterGap >0:
if iterWeek < iterGap:
iterGap = iterGap- iterWeek
iterYear = iterYear +1
iterWeek = Week.last_week_of_year(iterYear).week
else:
iterWeek = iterGap
iterGap =0
return str(iterYear)+"{:02d}".format(iterWeek)
else:
return str(currYear) +"{:02d}".format(currWeek+gapWeek)
def week_display():
# Default view is the current week.
if session.week is None:
session.week = Week.thisweek()[1]
session.year = date.today().year
week = session.week
year = session.year
# some years end in week 53, others in week 52
lastweekofyear = Week.last_week_of_year(year)[1]
# If it is the last week of the year, fix forward button
if lastweekofyear == week:
forward = {"week":1,"year":year + 1}
else:
forward = {"week":week + 1,"year":year}
# If it is the first week of the year, fix back button
if week == 1:
back = {"week":Week.last_week_of_year(year - 1)[1],"year":year - 1}
else:
back = {"week":week - 1,"year":year}
# Our startdate will be current week, beginning with monday
# set remaining sessions to new values and move on
session.startday = Week(year, week).monday()
session.back = back
session.forward = forward
session.week = week
session.year = year
def preWeek(inputYearWeek,gapWeek):
inputYearWeek=str(inputYearWeek)
gapWeek =int(gapWeek)
currYear = int(inputYearWeek[0:4])
currWeek = int(inputYearWeek[4:6])
#calendar.setTime(dateFormat.parse(currYear + "1231"));
Week.last_week_of_year(currYear).week
if(currWeek <=gapWeek):
iterGap= gapWeek -currWeek
iterYear = currYear -1
iterWeek= Week.last_week_of_year(iterYear).week
while iterGap >0:
if iterWeek <= iterGap:
iterGap = iterGap -iterWeek
iterYear = iterYear - 1
iterWeek = Week.last_week_of_year(iterYear).week
else:
iterWeek = iterWeek - iterGap
iterGap =0
return str(iterYear)+"{:02d}".format(iterWeek)
else:
resultYear = currYear
resultWeek = currWeek -gapWeek
return str(resultYear)+"{:02d}".format(resultWeek)
def create_list_weeks_years(week: int, year: int,
number_weeks_analyze: int) -> list:
"""
Create list of list with the information of the week and the year, taking into account the break of end of the year
:param week: last week to analyze
:param year: year of the week
:param number_weeks_analyze: number of week to analyze
:return: list of list with the oairs to analyze the sentiment
"""
if week <= number_weeks_analyze:
number_weeks_year_before = int(
str(Week.last_week_of_year(year - 1))[-2:])
list_week = list(
range(number_weeks_year_before - (number_weeks_analyze - week - 1), number_weeks_year_before + 1)) \
+ list(range(1, week + 1))
list_year = [year - 1] * len(
list(range(number_weeks_year_before - (number_weeks_analyze - week - 1), number_weeks_year_before + 1))) \
+ [year] * len(list(range(1, week + 1)))
else:
list_week = list(range(week - number_weeks_analyze + 1, week + 1))
list_year = [year] * len(list_week)
list_w_y = list(zip(list_week, list_year))
list_w_y = [list(elem) for elem in list_w_y]
return list_w_y
def post(self, request, *args, **kwargs):
year = kwargs.get('year') or datetime.datetime.now().year
week = kwargs.get('week') or Week.thisweek().week
if week < 1 or week > Week.last_week_of_year(year).week:
raise Http404('Invalid week / year.')
next_year, next_week = self.calc_next(year, week)
previous_year, previous_week = self.calc_previous(year, week)
row_formset = self.form_class(request.POST)
if row_formset.is_valid():
row_formset.save()
success_url = reverse('home-param', args=(year, week))
return HttpResponseRedirect(success_url)
create_row_form = RowModelForm()
return render(
request, self.template_name, {
'create_row_form': create_row_form,
'row_formset': row_formset,
'week': week,
'year': year,
'next_week': next_week,
'next_year': next_year,
'previous_week': previous_week,
'previous_year': previous_year
})
def get(self, request, *args, **kwargs):
year = kwargs.get('year') or datetime.datetime.now().year
week = kwargs.get('week') or Week.thisweek().week
if week < 1 or week > Week.last_week_of_year(year).week:
raise Http404('Invalid week / year.')
next_year, next_week = self.calc_next(year, week)
previous_year, previous_week = self.calc_previous(year, week)
rows = RowModel.objects.filter(year=year, week=week)
row_formset = self.form_class(queryset=rows)
create_row_form = RowModelForm()
return render(
request, self.template_name, {
'create_row_form': create_row_form,
'row_formset': row_formset,
'week': week,
'year': year,
'next_week': next_week,
'next_year': next_year,
'previous_week': previous_week,
'previous_year': previous_year
})
def yearWeekFunction(nowYearWeek, minusValue):
# 현재 연주차 정보를 연도와 주차로 나누고 정수로 형변환한다.
nowYearWeek = str(nowYearWeek)
currYear = int(nowYearWeek[:4])
currWeek = int(nowYearWeek[4:])
# 현재 주차에서 x주를 뺀 값을 지역변수로 저장한다
beforeWeek = currWeek - int(minusValue)
# x주 전 연도를 지역변수로 저장한다.
beforeYear = currYear
#x주 전 주차가 양수가 될 때까지 다음 과정을 반복한다.
while beforeWeek <= 0:
#전년도 정보와 x주 전 주차를 각각 문자열로 형변환하여 저장한다.
beforeWeek = Week.last_week_of_year(beforeYear).week + beforeWeek
beforeYear = beforeYear - 1
# return 값을 반환할 지역변수 설정
beforeYearWeek = ""
# 주차가 한자리 수일 경우 0을 붙일 변수 설정
weekOneDigit = "0"
beforeWeekLen = len(str(beforeWeek))
# 주차가 한자리 수인가?
if beforeWeekLen == 1:
# 그렇다면 주차에 0을 붙이고 합친다
beforeWeek = weekOneDigit + str(beforeWeek)
beforeYearWeek = str(beforeYear) + str(beforeWeek)
# 아니라면 그대로 합친다
else:
beforeYearWeek = str(beforeYear) + str(beforeWeek)
return beforeYearWeek
def get_data(self, year):
type_comanys = [
dict(pk=i.pk, name=i.name) for i in TypeCompany.objects.all()
]
data = []
_range = Week.last_week_of_year(year)[1]
for i in range(_range):
number = i + 1
date_list = Week(year, number).days()
month = self.get_month_from_week(date_list)
first, last = DateInsopesca(year,
number).get_date_range_from_week()
data.append(
dict(range_week=f'{first} a {last}',
inspections_total=[],
month=month,
total_col=0))
for type_comany in type_comanys:
inspection_total = 0
companys = Company.objects.filter(
type_company=type_comany['pk'])
for company in companys:
inspections = company.get_inspections(
f'{year}-{number}', f'{year}-{number}')
inspection_total += len(inspections)
data[i]['inspections_total'].append(inspection_total)
data[i]['total_col'] += inspection_total
total = 0
for tot in data:
total += tot['total_col']
return data, type_comanys, total
def preWeek(yearweek, input_weeks):
from isoweek import Week
yearweek = str(yearweek)
year = yearweek[:4]
week = yearweek[4:]
# 계산을 위해 정수형으로 변환
year = int(year)
week = int(week)
input_weeks = int(input_weeks)
# week <= input_weeks
if (week <= input_weeks):
while (week <= input_weeks):
year = year - 1
week = Week.last_week_of_year(year).week + week
week = week - input_weeks
# week > input_weeks
else:
week = week - input_weeks
# week이 1~9일경우 "0" 앞에 추가
if (week < 10):
week = "0" + str(week)
# 계산이 끝났으니 str로 변환후 합침
result = str(year) + str(week)
return result
def get_sparse_schedule(user_id: int):
if not user_util.get_from_id(user_id):
return api_error_helpers.item_not_found("user", "id", user_id)
start_str = request.args.get("start_week", default=None, type=str)
end_str = request.args.get("end_week", default=None, type=str)
year = request.args.get("year", default=None, type=int)
if (start_str or end_str) and year:
return api_error_helpers.invalid_url_args_combination(
["start_str", "end_str", "year"])
if not ((start_str and end_str) or year):
if not (start_str and end_str):
return api_error_helpers.missing_url_arg("start_week and end_week")
else:
return api_error_helpers.missing_url_arg("year")
start_week = Week.fromstring(start_str).toordinal() if start_str else None
end_week = Week.fromstring(end_str).toordinal() if end_str else None
if year:
start_week = Week(year, 1)
end_week = Week.last_week_of_year(year)
schedule_map = schedule_util.get_user_schedules(user_id, start_week,
end_week)
return jsonify(list(sched.serialize() for sched in schedule_map.values()))
def generate_header():
dob = dt.datetime(1989, 5, 28, tzinfo=pytz.timezone('utc'))
now = dt.datetime.now(tz=pytz.timezone('utc'))
last_year = now.year - 1
last_week_of_last_year = Week.last_week_of_year(last_year).week
age = relativedelta(now, dob).years
my_birthday_happened_this_year = now > dt.datetime(
now.year, 5, 28, tzinfo=pytz.timezone('utc'))
if my_birthday_happened_this_year:
last_birthday = dt.datetime(now.year, 5, 28)
weeks_lived_this_year = Week.thisweek().week - Week.withdate(
last_birthday).week
else:
last_birthday = dt.datetime(last_year, 5, 28)
weeks_lived_this_year = Week.withdate(
now).week + last_week_of_last_year - Week.withdate(
last_birthday).week
seasons = [
([3, 4, 5], 'Spring ❀'),
([6, 7, 8], 'Summer ☀'),
([9, 10, 11], 'Fall ☕︎'),
([1, 2, 12], 'Winter ❄'),
]
season_week_number = 0
for season in seasons:
if now.month in season[0]:
current_season = season[1]
season_week_number = Week.thisweek().week - Week.withdate(
dt.datetime(
now.year, season[0][0], 1,
tzinfo=pytz.timezone('utc'))).week
if now.month in [1, 2]:
season_week_number += last_week_of_last_year - Week.withdate(
dt.datetime(last_year, 12, 1,
tzinfo=pytz.timezone('utc'))).week
assert season_week_number > 0
# seasonal loader
empty = '░'
empty_amount = empty * (13 - (season_week_number - 1)) * 2
filled = '▓'
filled_amount = filled * (season_week_number - 1) * 2
# Subtracting one because I generate these at the beginning of the week
loader = "{0}{1}".format(filled_amount, empty_amount)
weeks_remaining = "/ {} weeks remaining /".format(13 -
season_week_number)
return "# {0} {1} {2}:13 ㄖ {3}:52\n{4} {5}".format(
age, current_season, season_week_number, weeks_lived_this_year,
loader, weeks_remaining)
def postWeek(yearWeek, postWeek): #postWeek 이후 주차를 반환하는 함수
from isoweek import Week
yeardigit = -2
inputYear = int(str(yearWeek)[:yeardigit]) #년도만 잘라서 저장
inputWeek = int(str(yearWeek)[yeardigit:]) #주차만 잘라서 저장
resultWeek = inputWeek + postWeek #현 주차 + 뒤로 갈 주차 계산결과
calcWeek = Week.last_week_of_year(inputYear).week
while (resultWeek > calcWeek): # 주차가 넘어간다면
inputYear = inputYear + 1 # 년도가 하나 늘어납니다
calcWeek = Week.last_week_of_year(inputYear).week #늘어난 년도의 총 주차수
resultWeek = resultWeek - calcWeek
#resultWeek 에서 총 주차를 빼줍니다
#결과가 아직도 총 주차보다 크다면 작아질때까지계속 반복
# if(resultWeek<10):
# resultWeek = "0"+str(resultWeek) # 1자릿수면 앞에 0을 붙여줌 -> zfill()로 처리.
result = str(inputYear) + str(resultWeek).zfill(2) #년도와 주차를 문자열로 더해서 출력
return result
def test_constructors(self):
w = Week(2011,1)
self.assertTrue(w)
self.assertEqual(str(w), "2011W01")
w = Week(2011,0)
self.assertEqual(str(w), "2010W52")
w = Week(2011,-1)
self.assertEqual(str(w), "2010W51")
w = Week(2011,52)
self.assertEqual(str(w), "2011W52")
w = Week(2011,53)
self.assertEqual(str(w), "2012W01")
w = Week(2011,54)
self.assertEqual(str(w), "2012W02")
w = Week(2009,51)
self.assertEqual(str(w), "2009W51")
w = Week(2009,52)
self.assertEqual(str(w), "2009W52")
w = Week(2009,53)
self.assertEqual(str(w), "2010W01")
w = Week(2009,54)
self.assertEqual(str(w), "2010W02")
w = Week.thisweek()
self.assertTrue(w)
w = Week.fromordinal(1)
self.assertEqual(str(w), "0001W01")
w = Week.fromordinal(2)
self.assertEqual(str(w), "0001W02")
w = Week.fromordinal(521723)
self.assertEqual(str(w), "9999W52")
w = Week.fromstring("2011W01")
self.assertEqual(str(w), "2011W01")
w = Week.fromstring("2011-W01")
self.assertEqual(str(w), "2011W01")
from datetime import date
w = Week.withdate(date(2011, 5, 17))
self.assertEqual(str(w), "2011W20")
self.assertEqual(Week.last_week_of_year(2009), Week(2009, 52))
self.assertEqual(Week.last_week_of_year(2010), Week(2010, 52))
self.assertEqual(Week.last_week_of_year(2011), Week(2011, 52))
self.assertEqual(Week.last_week_of_year(9999), Week(9999, 52))
self.assertRaises(ValueError, lambda: Week(0, 0))
self.assertRaises(ValueError, lambda: Week.fromstring("0000W00"))
self.assertRaises(ValueError, lambda: Week.fromstring("foo"))
self.assertRaises(ValueError, lambda: Week.fromordinal(-1))
self.assertRaises(ValueError, lambda: Week.fromordinal(0))
self.assertRaises(ValueError, lambda: Week.fromordinal(521724))
self.assertRaises(ValueError, lambda: Week.last_week_of_year(0))
self.assertRaises(ValueError, lambda: Week.last_week_of_year(10000))
def get_weekend_dates_for_years(number_of_years):
#Calculate the current week number for current year
weeks = Week.thisweek().week
#For previous years
for i in range(1, number_of_years):
#calculate the year
year = date.today().year - i
#Check how many weeks are there in the year calculated above and add it to weeks
weeks = weeks + Week.last_week_of_year(year).week
# define an empty list to store the week end dates
week_array = []
#Now we will have to loops "weeks" number of times and get the week end date
dt = date.today()
for i in range(1, weeks):
strd = dt - timedelta(days=dt.isoweekday() + 1 + (7 * i))
week_array.append(strd.strftime('%m-%d-%Y'))
return week_array
def preWeek(inputYearWeek, inputWeek):
#yearWeek = str(yearWeek)
year = int(inputYearWeek[0:4])
week1 = int(inputYearWeek[4:])
calcWeek = week1 - inputWeek
# 년도 몇주차 인지 자동계산 함수를 변수 maxWeek 담기
maxWeek = Week.last_week_of_year(year).week
# if 문으로 주차 계산
if (week1 > inputWeek): # 예) 2020.20(week1)>10(inputWeek) 그냥 빼기
answerWeek1 = str(int(inputYearWeek) - inputWeek)
print(answerWeek1)
while calcWeek <= 0:
year = year - 1
calcWeek = maxWeek + calcWeek
if (calcWeek < 10):
outValue = str(year) + "0" + str(calcWeek)
else:
outValue = str(year) + str(calcWeek)
return outValue
def get_schedule(user_id: int):
if not user_util.get_from_id(user_id):
return api_error_helpers.item_not_found("user", "id", user_id)
year = request.args.get("year", default=None, type=int)
if not year:
return api_error_helpers.missing_url_arg("year")
start_week = Week(year, 1)
end_week = Week.last_week_of_year(year)
user_projects = user_util.get_projects_for_period(user_id=user_id,
start_week=start_week,
end_week=end_week)
project_index = {
proj.id: index
for index, proj in enumerate(user_projects)
}
full_schedule = [[0 for project in user_projects]
for week in Week.weeks_of_year(year)]
schedule_dict = schedule_util.get_user_schedules(user_id,
start_week.toordinal(),
end_week.toordinal())
print(schedule_dict)
for week_project, schedule in schedule_dict.items():
week_index = Week.fromordinal(week_project.week).week - 1
full_schedule[week_index][project_index[
week_project.project_id]] = schedule.hours
return jsonify(
projects=list(map(lambda x: x.serialize(), user_projects)),
schedule=full_schedule,
)
def clean(self):
cleaned_data = super(RowModelForm, self).clean()
year = cleaned_data.get('year')
week = cleaned_data.get('week')
if year is None:
raise ValidationError({'year': 'Year cannot be empty.'})
if week is None:
raise ValidationError({'week': 'Week cannot be empty.'})
# Validate week number
if week < 1 or week > Week.last_week_of_year(year).week:
raise ValidationError(
{'week': 'Week does not exist on this year.'})
# Validate day is not exceeded.
days = ['day_1', 'day_2', 'day_3', 'day_4', 'day_5', 'day_6', 'day_7']
for day in days:
current_day = cleaned_data.get(day)
if current_day is not None and current_day > timedelta(hours=24):
raise ValidationError({day: 'Value cannot exceed 24 hours.'})
return cleaned_data
week = response.json()["data"]["lessonInfo"]
#create empty object for lessons
while True:
today = {"list": []}
for x in week:
#add only lessons for current day to object
if x["dayOfWeekNumber"] == date:
today["list"].append(x)
#format lesson object nicer
today = today["list"]
if (not today):
if (date == 7):
print("[INFO]\tDay was empty, trying first day of next week")
date = 1
data["week"] = data["week"] + 1
if (data["week"] == Week.last_week_of_year(data["year"])):
print("[INFO]\tLast week of year, trying next year.")
data["year"] = data["year"] + 1
data["week"] = 1
else:
print("[INFO]\tDay was empty, trying next day")
date += 1
else:
break
#function to return starttime for comparison
def startTime(elem):
return (datetime.datetime.combine(
datetime.datetime.today(),
datetime.datetime.strptime(elem["timeStart"], '%H:%M:%S').time()) -
datetime.datetime(1970, 1, 1)).total_seconds()
def test_constructors(self):
w = Week(2011, 1)
self.assertTrue(w)
self.assertEqual(str(w), "2011W01")
w = Week(2011, 0)
self.assertEqual(str(w), "2010W52")
w = Week(2011, -1)
self.assertEqual(str(w), "2010W51")
w = Week(2011, 52)
self.assertEqual(str(w), "2011W52")
w = Week(2011, 53)
self.assertEqual(str(w), "2012W01")
w = Week(2011, 54)
self.assertEqual(str(w), "2012W02")
w = Week(2009, 51)
self.assertEqual(str(w), "2009W51")
w = Week(2009, 52)
self.assertEqual(str(w), "2009W52")
w = Week(2009, 53)
self.assertEqual(str(w), "2009W53")
w = Week(2009, 54)
self.assertEqual(str(w), "2010W01")
w = Week.thisweek()
self.assertTrue(w)
w = Week.fromordinal(1)
self.assertEqual(str(w), "0001W01")
w = Week.fromordinal(2)
self.assertEqual(str(w), "0001W02")
w = Week.fromordinal(521723)
self.assertEqual(str(w), "9999W52")
w = Week.fromstring("2011W01")
self.assertEqual(str(w), "2011W01")
w = Week.fromstring("2011-W01")
self.assertEqual(str(w), "2011W01")
from datetime import date
w = Week.withdate(date(2011, 5, 17))
self.assertEqual(str(w), "2011W20")
weeks = list(Week.weeks_of_year(2009))
self.assertEqual(len(weeks), 53)
self.assertEqual(weeks[0], Week(2009, 1))
self.assertEqual(weeks[-1], Week(2009, 53))
weeks = list(Week.weeks_of_year(2011))
self.assertEqual(len(weeks), 52)
self.assertEqual(weeks[0], Week(2011, 1))
self.assertEqual(weeks[-1], Week(2011, 52))
self.assertEqual(Week.last_week_of_year(2009), Week(2009, 53))
self.assertEqual(Week.last_week_of_year(2010), Week(2010, 52))
self.assertEqual(Week.last_week_of_year(2011), Week(2011, 52))
self.assertEqual(Week.last_week_of_year(9999), Week(9999, 52))
self.assertRaises(ValueError, lambda: Week(0, 0))
self.assertRaises(ValueError, lambda: Week.fromstring("0000W00"))
self.assertRaises(ValueError, lambda: Week.fromstring("foo"))
self.assertRaises(ValueError, lambda: Week.fromordinal(-1))
self.assertRaises(ValueError, lambda: Week.fromordinal(0))
self.assertRaises(ValueError, lambda: Week.fromordinal(521724))
self.assertRaises(ValueError, lambda: Week.last_week_of_year(0))
self.assertRaises(ValueError, lambda: Week.last_week_of_year(10000))
def calc_next(current_year, current_week):
if current_week + 1 > Week.last_week_of_year(current_year).week:
return current_year + 1, 1
return current_year, current_week + 1
def calc_previous(current_year, current_week):
if current_week - 1 < 1:
return current_year - 1, Week.last_week_of_year(current_year -
1).week
return current_year, current_week - 1
def timetable(request, year=0, week=0, act=None):
employees = Employee.objects.all()
ldate = Shift.objects.all().aggregate(Max('date'))
shifts = Shift.objects.filter(date=ldate['date__max'])
(year, week) = (int(year), int(week))
w = Week(year, week)
# last week of current year
lastw = w.last_week_of_year(year)[1]
# last week of year before
lastw_b = w.last_week_of_year(year - 1)[1]
dates = [w.monday() + timedelta(days=i) for i in range(0, 7)]
if act == 'copy':
for d in dates:
Timetable.objects.filter(date=d).delete()
for s in shifts:
try:
e = Timetable.objects.get(date=d - timedelta(7),
shift=s.pk).employee
tt = Timetable(date=d, shift=s, employee=e)
tt.save()
except Timetable.DoesNotExist:
pass
url = reverse('e_timetable',
kwargs={
'year': year,
'week': week,
'act': 0
})
return HttpResponseRedirect(url)
if request.method == 'POST':
post_values = {}
i = 0
employees = request.POST.getlist('employees')
for j in range(0, 7):
for s in shifts:
post_values['date'] = dates[j]
post_values['shift'] = s.pk
try:
ttable = Timetable.objects.get(date=post_values['date'],
shift=s.pk)
ttable.delete()
except Timetable.DoesNotExist:
pass
post_values['employee'] = employees[i]
if employees[i] != '0':
f = FormTimetable(post_values)
if f.is_valid():
f.save()
else:
return HttpResponse(f.errors, mimetype='text/html')
i += 1
context_dict = dict(
request=request,
week=week,
dates=dates,
shifts=shifts,
year=year,
lastw=lastw,
lastw_b=lastw_b,
employees=employees,
act=act,
)
if act == 'edit':
context_dict.update(csrf(request))
return render_to_response('timetable.html', context_dict)
