def get_week_agenda(model, queryset, start_date):
"""
Get list of events that will occur in the given week.
:param queryset: EventInstance queryset
:param start_date: period start_date
:type start_date: datetime.datetime()
:return: data dictionary
"""
period = Week(start_date.year, start_date.date().isocalendar()[1])
end_date = utils.date_to_datetime(period.sunday(), 'max')
start_date = utils.date_to_datetime(period.monday())
return {
'start_date':
start_date,
'end_date':
end_date,
'scope':
'Week',
'items':
model.objects.in_date_range(start_date,
end_date).filter(event__in=queryset),
'next_date':
start_date + timedelta(days=7),
'previous_date':
start_date + timedelta(days=-7),
}
def scrapper(self) -> str or None:
date = Week(self.year_no, self.week_no)
month = date.day(0).month
options = webdriver.ChromeOptions()
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")
options.add_argument("--headless")
browser = webdriver.Chrome(
options=options, executable_path=conf.CHROME_DRIVER_PATH
)
log(log.INFO, "Start get url Norfolk Southern")
browser.get(self.URL)
log(log.INFO, "Get url Norfolk Southern")
generated_html = browser.page_source
soup = BeautifulSoup(generated_html, "html.parser")
tags = soup.find_all("a")
log(log.INFO, "Get all links Norfolk Southern")
link = [
link.attrs["href"]
for link in tags
if f"weekly-performance-reports/{self.year_no}/investor-weekly-carloads"
in link.attrs["href"]
]
if not link:
log(log.WARNING, "Links not found")
return None
log(log.INFO, "Get link with pdf for Norfolk Southern")
link = "http://www.nscorp.com" + link[month - 1]
log(log.INFO, "Found pdf link: [%s]", link)
return link
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 validate_period(period, first_date):
'''
make sure only period is between first_date and today
'''
today = datetime.now().strftime('%Y%m%d')
# Day yyyyMMdd
if type_of_period(period) == 'day':
if period >= first_date and period <= today:
return True
# Week yyyy-Www
elif type_of_period(period) == 'week':
this_week = Week.thisweek()
period_week = Week.fromstring(period)
first_date_week = Week.withdate(datetime.strptime(first_date, '%Y%m%d'))
if period_week >= first_date_week and period_week <= this_week:
return True
# Month yyyyMM
elif type_of_period(period) == 'month':
this_month = datetime.now().strftime('%Y%m')
period_month = period[0:6]
first_date_month = first_date[0:6]
if period_month >= first_date_month and period_month <= this_month:
return True
return False
def google_kursk(year,week,FraudOrder):
credentials = 'templates/js/client_secret.json'
scope = ['https://spreadsheets.google.com/feeds','https://www.googleapis.com/auth/drive']
credentials = ServiceAccountCredentials.from_json_keyfile_name(credentials, scope)
gc = gspread.authorize(credentials)
wks=gc.open_by_key("1eYS1QbeYS3E_zV3uagBjvIt25xYLWsLbztl8sd9uG5w")
date_from, date_to = Week(int(year), int(week)).monday().strftime('%Y%m%d'),Week(int(year),int(week)).sunday().strftime('%Y%m%d')
name_sheet = date_from[:4] + '.' + date_from[4:6] + '.' + date_from[6:] + ' - ' + date_to[:4] + '.' + date_to[4:6] + '.' + date_to[6:]
check_worksheet_name = 0
for i in wks.worksheets():
if i.title != name_sheet:
pass
else:
check_worksheet_name = 1
if check_worksheet_name == 1:
pass
else:
wks.duplicate_sheet(wks.worksheet('шаблон').id,
new_sheet_name=name_sheet)
wks.values_update(
name_sheet + '!A4',
params={
'valueInputOption': 'USER_ENTERED'
},
body={
'values': FraudOrder
}
)
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 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(_, week=None):
# Make your own library for ISO week parsing. this one sucks
if not week:
week = Week.withdate(datetime.now())
else:
try:
ws = week.split("-")
if len(ws) == 3:
week = "".join(ws[0:-1])
week = Week.fromstring(week)
except ValueError:
return (
FailResponse(
week="week path variable must be a proper ISO week date"
),
400,
)
try:
token = Token(request.headers.get("X-API-KEY"))
except:
return FailResponse(token="malformed token"), 400
units = []
if token:
try:
monday = datetime.combine(week.monday(), datetime.min.time())
units = lesson_units(token, monday)
units = list(map(serialize_unit, units))
return SuccessResponse(units=units, week=week.isoformat())
except AuthorizationError as e:
return ErrorResponse(str(e)), 403
else:
return ErrorResponse("Unauthorized"), 401
def get_hiatus_weeks(air_weeks):
iso_week_nums = []
for week in air_weeks:
dt = date(2018, int(week.split('/')[0]), int(week.split('/')[1]))
wk = dt.isocalendar()[1]
iso_week_nums.append(wk)
index = 0
hiatus_week_nums = []
while index < len(iso_week_nums) - 1:
if iso_week_nums[index + 1] - iso_week_nums[index] > 1:
week_before = iso_week_nums[index]
week_after = iso_week_nums[index + 1]
weeks_to_add = week_after - week_before - 1
for x in range(weeks_to_add):
week_before += 1
hiatus_week_nums.append(week_before)
index += 1
hiatus_weeks = []
for week in hiatus_week_nums:
d = Week(2018, week).monday()
d = d.strftime('%m/%d')
hiatus_weeks.append(d)
return hiatus_weeks
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 convert_to_catergory_str(year, week):
isoweek = Week(year, week)
monday = isoweek.monday()
sunday = isoweek.sunday()
return monday.strftime(
DATE_FORMAT_SHORT_MONTH_DAY) + '~' + sunday.strftime(
DATE_FORMAT_SHORT_MONTH_DAY)
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 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 get_menus_list(self):
r = requests.get("https://sites.google.com/site/fedorestbe/menu-fr/menu-noga-fr")
soup = BeautifulSoup(r.content, "lxml")
current_week = Week.thisweek().week
current_year = Week.thisweek().year
content = ""
content += "Voici les menus disponibles concoctes par les chefs Fedorest. Nous sommes en semaine {}-{} : \n".format(current_year, current_week)
link_cells = soup.find_all("td", {"class": "td-file"})
regex = r"noga_fr_(\d+)_(\d+)\.pdf"
for cell in link_cells:
links = cell.find_all("a")
for link in links:
url = link.get("href")
matches = re.findall(regex, url)
if matches:
(week, year) = matches[0]
content += "* ["+year + "-"+week + "](" + GOOGLE_SITE_BASE + url + ")\n"
return content
def trips_affecting_the_bonus_plan(city_id, date_start, date_end,
city_bonus_plan_dict):
date_format = "%Y-%m-%d"
city_id = str(city_id)
nedels = []
a = dt.strptime(date_start, date_format)
b = dt.strptime(date_end, date_format)
delta = b - a
for i in range(delta.days + 1):
year, month, day = (
(dt.strptime(date_start, date_format) +
timedelta(days=i)).strftime(date_format)).split('-')
nedel = datetime.date(int(year), int(month), int(day)).isocalendar()[1]
if [year, nedel] not in nedels:
nedels.append([year, nedel])
for i in nedels:
year = i[0]
week = i[1]
date_from, date_to = (Week(
int(year), int(week)).monday().strftime('%Y%m%d')), (Week(
int(year), int(week + 1)).monday().strftime('%Y%m%d'))
min_trips_for_bonus = city_bonus_plan_dict[-1][0]
TotalFraudTable_ned(date_from, date_to, city_id, week, year,
min_trips_for_bonus, city_bonus_plan_dict)
return
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
start = self.fields['start']
cw = Week.thisweek()
choices = [str(w + cw.week) for w in Week.weeks_of_year(cw.year)]
start.choices = zip(choices, choices)
start.initial = cw+1
def execute_goals(self):
week_day = datetime.datetime.now().isocalendar()[1]
w = Week(datetime.datetime.now().year, week_day)
start_date = w.monday()
end_date = w.sunday()
result = Records.objects.filter(
create_date_time__date__range=(start_date, end_date),
type_entry__id=1).annotate(total_value=Sum("debit"))
try:
total_debit = 0
for a in result:
total_debit += a.total_value if a.total_value else 0
logging.warning(f"total_debit: {total_debit}")
can_use = 770 - total_debit
loop = asyncio.get_event_loop()
bot = telepot.aio.Bot(settings.TELEGRAM_TOKEN)
loop.run_until_complete(
bot.sendMessage(
self.user_id,
f"Você ainda pode gastar {can_use} doas 770 reais estipulados para a semana."
))
except BaseException as e:
logging.exception("Error na meta", e)
def decide_forecast_time(timeby,value):
if timeby == "Daily":
d = "2014"+value[4:]
start = parse(d)
starti = (parse(d)-parse('2014-1-1')).days * 24
end = parse(d)+timedelta(days=1)
endi = starti + 24
elif timeby == "Weekly":
d = Week(2011, 40).monday()
s = d.strftime("%Y-%m-%d")
d = "2014"+s[4:]
start = parse(d)
starti = (parse(d)-parse('2014-1-1')).days * 24
end = parse(d)+timedelta(days=7)
endi = starti + (7*24)
else:
d = get_first_date(value)
start = parse(d)
starti = (parse(d)-parse('2014-1-1')).days * 24
end = parse(d)+timedelta(days=30)
endi = starti + (30*24)
if end.year == 2015:
end = parse("2014-12-31")
endi = starti + ((end-parse(d)).days *24)
return start,end,starti,endi
def handle_noargs(self, **options):
translation.activate('fr')
week_limit = Week.withdate(Week.thisweek().day(settings.VALIDATING_DAY_OF_WEEK) + relativedelta(days=settings.DELAY_BETWEEN_DEFINITON_N_DELIVERY))
deliveries = models.Delivery.objects.filter(date__lte=week_limit, status='P', subscription__enabled=True).order_by('subscription__customer__account__email')
count=0
for delivery in deliveries:
logger_delivery = logging.getLogger('[%d]' % delivery.id)
subscription = delivery.subscription
customer = subscription.customer
logger_delivery.info(delivery.__unicode__())
for content in delivery.content_set.all():
__extent = content.extent
logger_content = logging.getLogger('[%d] [%20s] [%c] [%3s%%]' % (delivery.id, content.product.name[:20], '*' if content.customized else ' ', __extent))
for contentproduct in content.contentproduct_set.all():
logger_content.info('%d x %20s (%4d) %s' % (contentproduct.quantity, contentproduct.product.name[:20], contentproduct.product.id, contentproduct.product.main_price.supplier_product_url))
if options['browse']:
webbrowser.open(contentproduct.product.main_price.supplier_product_url)
count += 1
if count >= options['pages']:
count = 0
try:
input()
except KeyboardInterrupt:
print('Interrupted'); sys.exit()
logger_delivery.info('')
translation.deactivate()
def getPrevWeekString(weekString):
annee = int(weekString[:4])
# on récupère le numéro de la semaine
sem = int(weekString[-2:])
week = Week(annee, sem)
lundi = week.monday()
dimanchePrecedent = lundi + timedelta(days=-1)
previousYear = dimanchePrecedent.strftime("%Y")
if (int(previousYear) == annee):
if (sem - 1) <= 9:
prevWeekString = previousYear + "0" + str(sem - 1)
else:
prevWeekString = previousYear + str(sem - 1)
else:
prevWeekNum = dimanchePrecedent.isocalendar()[1]
if prevWeekNum <= 9:
prevWeekString = previousYear + "0" + str(prevWeekNum)
else:
prevWeekString = previousYear + str(prevWeekNum)
return prevWeekString
def decide_forecast_time(timeby, value):
if timeby == "Daily":
d = "2014" + value[4:]
start = parse(d)
starti = (parse(d) - parse('2014-1-1')).days * 24
end = parse(d) + timedelta(days=1)
endi = starti + 24
elif timeby == "Weekly":
d = Week(2011, 40).monday()
s = d.strftime("%Y-%m-%d")
d = "2014" + s[4:]
start = parse(d)
starti = (parse(d) - parse('2014-1-1')).days * 24
end = parse(d) + timedelta(days=7)
endi = starti + (7 * 24)
else:
d = get_first_date(value)
start = parse(d)
starti = (parse(d) - parse('2014-1-1')).days * 24
end = parse(d) + timedelta(days=30)
endi = starti + (30 * 24)
if end.year == 2015:
end = parse("2014-12-31")
endi = starti + ((end - parse(d)).days * 24)
return start, end, starti, endi
def handle_noargs(self, **options):
translation.activate('fr')
logging.debug('Command in progress')
week_limit = Week.withdate(Week.thisweek().day(settings.VALIDATING_DAY_OF_WEEK) + relativedelta(days=settings.DELAY_BETWEEN_DEFINITON_N_DELIVERY))
# first changed the status of expired deliveries
deliveries_canceled = models.Delivery.objects.filter(date__lt=week_limit, status='w', subscription__enabled=True)
for delivery in deliveries_canceled:
delivery.status = 'e'
delivery.save()
logging.debug('delivery %d expired' % delivery.id)
# secondly, get all the deliveries with a date higher or equal to J+9 and lesser than J+9+7 with a waiting status and a subscription which accepts direct debit.
deliveries = models.Delivery.objects.filter(date__gte=week_limit, date__lt=week_limit+1, status='w', subscription__direct_debit=True, subscription__enabled=True)
for delivery in deliveries:
delivery.status = 'p'
try:
delivery.save()
except ValueError as e:
logging.debug('delivery %d not payed' % delivery.id)
else:
logging.debug('delivery %d payed' % delivery.id)
translation.deactivate()
class WeekView(AjaxableViewMixin, CalendarMixin, ListView):
model = events.Event
context_object_name = 'events'
template_name = 'gamenightplanner/calendar/week.html'
def dispatch(self, request, year, week, *args, **kwargs):
self.week = Week(int(year), int(week))
return super().dispatch(request, *args, **kwargs)
def get_queryset(self):
return self.model.objects.filter(date__date__gte=self.week.monday(),
date__date__lte=self.week.sunday())
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['year'] = self.week.year
context['month'] = self.week.monday().month
context['week'] = self.week
context['daysofweeknames'] = self.DAYSOFWEEK
context['daysofweekshort'] = self.DAYSOFWEEK_SHORT
context['current_url'] = self.week_link(self.week)
context['next_url'] = self.week_link(self.week+1)
context['prev_url'] = self.week_link(self.week-1)
return context
def format_week(week):
week = week.lower()
if "-" in week:
week_list = week.split("-")
elif "/" in week:
week_list = week.split("/")
elif "w" in week:
week_list = week.split("w")
else:
week_list = ["", week]
if "w" in week_list[0]:
week_number = week_list[0].replace("w", "").rjust(2, "0")
year = ("20" +
week_list[1]) if len(week_list[1]) == 2 else week_list[1]
else:
week_number = week_list[1].replace("w", "").rjust(2, "0")
year = "20" + week_list[0] if len(week_list[0]) == 2 else week_list[0]
if not year:
this_week = Week.thisweek()
if int(week_number) < this_week.week:
year = str(this_week.year + 1)
else:
year = str(this_week.year)
return Week.fromstring(year + "W" + week_number)
def validate_period(period, first_date):
'''
make sure only period is between first_date and today
'''
today = datetime.now().strftime('%Y%m%d')
# Day yyyyMMdd
if type_of_period(period) == 'day':
if period >= first_date and period <= today:
return True
# Week yyyy-Www
elif type_of_period(period) == 'week':
this_week = Week.thisweek()
period_week = Week.fromstring(period)
first_date_week = Week.withdate(datetime.strptime(
first_date, '%Y%m%d'))
if period_week >= first_date_week and period_week <= this_week:
return True
# Month yyyyMM
elif type_of_period(period) == 'month':
this_month = datetime.now().strftime('%Y%m')
period_month = period[0:6]
first_date_month = first_date[0:6]
if period_month >= first_date_month and period_month <= this_month:
return True
return False
def create_deliveries(self):
s, e = Week.fromstring(str(self.start)), Week.fromstring(str(self.end))
if self.receive_only_once:
d = self.delivery_set.create(date=s)
else:
for i in range(0, e+1-s, self.frequency):
d = self.delivery_set.create(date=s+i)
def weekly_report(self, request):
""" Gets data from database and formats weekly report """
# weeks sum and average aggregation
# NOTE: only works with sqlite
weeks = Expense.objects.filter(user=request.user).extra({
"week": "strftime('%Y%W', datetime)"}).values('week').\
order_by('week').annotate(total=Sum('amount'),
average=Avg('amount'),
count=Count('amount'))
weeks = {w['week']: w for w in weeks}
# expenses per week
# NOTE: only works with sqlite
weeks_expenses = Expense.objects.filter(user=request.user).extra(
{"week": "strftime('%Y%W', datetime)"}).order_by('datetime')
# adjusting data
for expense in weeks_expenses:
week = weeks[expense.week]
if 'expenses' not in week:
week['expenses'] = []
week['expenses'].append(ExpenseSerializer(expense).data)
week['initialDate'] = Week(int(week['week'][:4]),
int(week['week'][4:]) + 1).monday()
week['finalDate'] = Week(int(week['week'][:4]),
int(week['week'][4:]) + 1).sunday()
return Response(sorted(weeks.values(), key=lambda x: x['week']))
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 test_mix_max(self):
self.assertEqual(Week.min, Week(1, 1))
self.assertEqual(Week.max, Week(9999, 52))
self.assertEqual(Week.resolution.days, 7)
self.assertRaises(ValueError, lambda: Week.min - 1)
self.assertRaises(ValueError, lambda: Week.max + 1)
def _task_completed(user_id, task_id, year, week_number):
""" Return true if a task is completed for this specific user and week """
week = Week(year, week_number)
monday = week.monday().isoformat()
next_monday = week.sunday() + timedelta(days=1)
return _db.is_task_completed(user_id, task_id, monday, next_monday)
def duration2(self):
if not self.start or not self.end: return None
s, e = Week.fromstring(self.start).day(1), Week.fromstring(self.end).day(1)
r = relativedelta(e,s)
ret = ''
if r.years: ret += _('%d years, ') % r.years
if r.months: ret += _('%d months, ') % r.months
if r.days: ret += _('%d days') % r.days
return ret
def w_range(start_date):
weeks_list = []
startWeek = Week.withdate(start_date)
endWeek = Week.thisweek()
int_week = startWeek
while int_week < endWeek:
int_week = int_week + 1
weeks_list.append(int_week)
return weeks_list
def serialize(self):
return {
"iso_week": Week.fromordinal(self.week).isoformat(),
"week_date": Week.fromordinal(self.week).monday().isoformat(),
"user_id": self.user_id,
"id": self.id,
"project_id": self.project_id,
"hours": self.hours,
}
def save(self, commit=True):
subscription = super().save(commit=False)
bw = Week.fromstring(self.cleaned_data['start'])
ew = Week.withdate( bw.day(1) + relativedelta(months=int(self.cleaned_data['duration'])) )
subscription.end = ew
if commit:
subscription.save()
subscription.create_deliveries()
return subscription
def get_ordinary_week(iso_week):
week = {
'monday': Week.fromstring(iso_week).monday().isoformat(),
'tuesday': Week.fromstring(iso_week).tuesday().isoformat(),
'wednesday': Week.fromstring(iso_week).wednesday().isoformat(),
'thursday': Week.fromstring(iso_week).thursday().isoformat(),
'friday': Week.fromstring(iso_week).friday().isoformat()
}
return week
def home(request, year=None, week=None):
if not year or not week:
# use previous week by default
week = Week.thisweek() - 1
else:
week = Week(int(year), int(week))
date_range = get_date_range(week)
# absolute worst titles
worst_titles = NewsItem.objects.filter(
published__range=date_range,
score__isnull=False).order_by('-score')[:5]
# worst sites on average
site_avg = Site.objects.filter(
newsitems__published__range=date_range,
newsitems__score__isnull=False).annotate(
score=Avg('newsitems__score')).order_by('-score')[:5]
# biggest percentage of bad titles
sites = Site.objects.filter(newsitems__published__range=date_range,
newsitems__score__isnull=False).annotate(
bad=Sum(
Case(When(newsitems__score__gt=1.0,
then=1),
output_field=IntegerField())),
total=Count('newsitems__score'),
)
percentages = []
# calculate percentages
for site in sites:
bad = float(site.bad if site.bad else 0)
total = float(site.total if site.total else 0)
percentage = int((bad / total) * 100)
percentages.append((percentage, site))
# sort by percentage and take top 5
percentages = list(reversed(sorted(percentages, key=lambda x: x[0])))[:5]
context = {
'worst_titles': worst_titles,
'site_avg': site_avg,
'bad_percentages': percentages,
'date_range': {
'week': week,
'start': date_range[0].date(),
'end': date_range[1].date(),
}
}
return render(request, 'home.html', context)
async def weekly_formula(start: date, end: date, *cuts: Cut) -> Iterator[Sales]:
first = Week.withdate(start) + 1
last = Week.withdate(end) + 1
start = first.monday()
if last.day(lm_pk620.weekday) < lm_pk620.latest:
last -= 1
records = await Repository(lm_pk620).query(start, last.saturday(), *report_sections(*cuts))
return map(parse_record, records)
def get_deliveries_from_subscription(subscription_data):
receive_only_once = subscription_data.get('receive_only_once')
bw = Week.fromstring(str(subscription_data.get('start')))
ew = Week.withdate( bw.day(1) + relativedelta(months=int(subscription_data.get('duration'))) )
nb = len(range(0, ew+1-bw, int(subscription_data.get('frequency'))))
init_price = subscription_data.get('size').default_price().price
prices = get_deliveries(nb, init_price)
if receive_only_once: prices = np.array([prices[0]])
deliveries = [(i+1, '%s (%s %s)' % ((bw+i*2).day(settings.DELIVERY_DAY_OF_WEEK).strftime('%d-%m-%Y'), _('Week'), (bw+i*2).week), p) for i,p in enumerate(prices)]
return deliveries, prices
async def weekly_negotiated(start: date, end: date, *cuts: Cut) -> Iterator[Sales]:
first = Week.withdate(start)
last = Week.withdate(min(date.today(), end))
start = first.monday()
if last.day(lm_pk610.weekday) < lm_pk610.latest:
last -= 1
records = await Repository(lm_pk610).query(start, last.saturday(), *report_sections(*cuts))
return map(parse_record, records)
def get_context_data(self, **kwargs):
semana = Semana.objects.get(id=self.kwargs['semana_id'])
inicio = Week(semana.creacion.isocalendar()[0],semana.creacion.isocalendar()[1]+1).tuesday()
fin = Week(semana.creacion.isocalendar()[0],semana.creacion.isocalendar()[1]+2).monday()
kwargs['start_date'] = inicio.strftime("%Y-%m-%d")
kwargs['end_date'] = fin.strftime("%Y-%m-%d")
kwargs['formador'] = Formador.objects.get(id=self.kwargs['id']).get_full_name()
kwargs['numero_semana'] = semana.numero
return super(CronogramaFormadorUpdateView,self).get_context_data(**kwargs)
def get_ini_and_end_date(g: Goal) -> Tuple:
if g.period == 1:
week_day = datetime.datetime.now().isocalendar()[1]
w = Week(datetime.datetime.now().year, week_day)
start_date = w.monday()
end_date = w.sunday()
return start_date, end_date
raise Exception("Invalid goal.")
def __init__(self, **kwargs):
for k, v in kwargs.iteritems():
self.__setattr__(k, v)
if kwargs["archive_date"]:
self.archive_week = Week.withdate(kwargs["archive_date"])
self.lead_time = kwargs["archive_date"] - kwargs["create_date"]
else:
self.archive_date = kwargs["last_move_date"]
self.archive_week = Week.withdate(kwargs["last_move_date"])
self.lead_time = kwargs["last_move_date"] - kwargs["create_date"]
def get_week_range(start_date):
"""
Get the start and end datetimes for the week
:param start_date: period start_date
:type start_date: datetime.datetime()
:return: tuple start_datetime, end_datetime
"""
period = Week(start_date.year, start_date.date().isocalendar()[1])
start_date = utils.date_to_datetime(period.monday())
end_date = utils.date_to_datetime(period.sunday(), 'max')
return start_date, end_date
def fix_weekly_date(apps, schema_editor):
CountryWeeklyStatus = apps.get_model('connection_statistics', 'CountryWeeklyStatus')
SchoolWeeklyStatus = apps.get_model('connection_statistics', 'SchoolWeeklyStatus')
for s in SchoolWeeklyStatus.objects.all():
s.date = Week(s.year, s.week).monday()
s.save()
for s in CountryWeeklyStatus.objects.all():
s.date = Week(s.year, s.week).monday()
s.save()
def get_context_data(self, **kwargs):
semana = Semana.objects.get(id=self.kwargs['semana_id'])
kwargs['informes'] = self.request.user.has_perm('permisos_sican.formacion.cronograma.informes')
kwargs['numero_semana'] = Semana.objects.get(id=self.kwargs['semana_id']).numero
kwargs['id_semana'] = self.kwargs['semana_id']
inicio = Week(semana.creacion.isocalendar()[0],semana.creacion.isocalendar()[1]+1).monday()
fin = Week(semana.creacion.isocalendar()[0],semana.creacion.isocalendar()[1]+1).sunday()
kwargs['fechas'] = inicio.strftime("%d de %B del %Y") + ' - ' + fin.strftime("%d de %B del %Y")
return super(ListaCronogramasSemanaView,self).get_context_data(**kwargs)
def _populate_year(self, year):
index = year - self.dob.year
start_week = Week.withdate(date(year, self.dob.month, self.dob.day))
end_week = Week.withdate(date(year + 1, self.dob.month, self.dob.day))
next_week = start_week
weeks = []
while next_week.monday() < end_week.monday():
week_info = WeekInfo(next_week)
weeks.append(week_info)
self._weeks[next_week] = week_info
next_week += 1
self._years[year] = dict(year=year, index=index, weeks=weeks)
def tracking_calendar(request, year=None, week=None):
'''
This view will get parameters from url and will try to generate
a table of the current week where reminders we get can be tracked.
'''
# If there is no year we generate it
if year == None:
ryear = date.today().year
else:
ryear = int(year)
# The same with the week
if week == None:
rweek = date.today().isocalendar()[1]
else:
rweek = int(week)
# If someone tries to insert manually a week which doesn't exist
# we return him/her a 403 page (have to change with something else).
if rweek > '53':
raise PermissionDenied()
isoweek = Week(ryear, rweek)
sqlweek = []
for x in range(5):
sqlweek.append(isoweek.day(x))
try:
RemindersTable.objects.get(rday=isoweek.day(0))
except RemindersTable.DoesNotExist:
for x in range(5):
RemindersTable.objects.create(rday=isoweek.day(x))
tableresults = []
dayrow = []
for day in sqlweek:
weekresults = RemindersTable.objects.filter(rday=day)
for value in weekresults.values_list()[0]:
dayrow.append(value)
tableresults.append(dayrow)
dayrow = []
headers = weekresults.values().field_names
return render_to_response("calendar.html", {'sqlweek': sqlweek,
'headers': headers,
'tableresults': tableresults}, RequestContext(request))
def get_context_data(self, **kwargs):
semana = Semana.objects.get(id=self.kwargs['semana_id'])
kwargs['formador'] = Formador.objects.get(id=self.kwargs['id']).get_full_name()
kwargs['semana_numero'] = semana.numero
kwargs['id_semana'] = semana.id
x, created = Semana.objects.get_or_create(numero = datetime.datetime.now().isocalendar()[1]+1)
inicio = Week(semana.creacion.isocalendar()[0],semana.creacion.isocalendar()[1]+1).monday()
fin = Week(semana.creacion.isocalendar()[0],semana.creacion.isocalendar()[1]+1).sunday()
kwargs['fechas'] = inicio.strftime("%d de %B del %Y") + ' - ' + fin.strftime("%d de %B del %Y")
kwargs['id_formador'] = self.kwargs['id']
return super(CronogramaFormadorView,self).get_context_data(**kwargs)
def getPartAssignment(self, co=None, numWeekInit=-1, numYearInit=-1, numWeekEnd=-1, numYearEnd=-1):
'''
Prend en parametre un ou plusieurs doublets du type : ("nom", "bob") => WHERE NOM='Bob'
Permet de récupérer un objet python depuis la base de donnée en fonction d'un filtre.
Le type d'objet retournée varie en fonction de la classe fille qui l'appel.
'''
TEMPLATE_WHERE_NAT = Template("select A.ID_WORKER as _worker_num, A.FIRST_NAME as _worker_firstName, A.NAME as _worker_name, A.ADDRESS as _worker_position_address," + \
"E.ID_SITE _phase_site_num, E.NUM_SITE as _phase_site_numSite, E.NUM_WEEK as _phase_numWeek, E.NUM_YEAR as _phase_numYear " + \
"from (select w.ID as ID_WORKER, w.FIRST_NAME, w.NAME, p.ADDRESS " + \
"from WORKER w, POSITION p " + \
"where w.ID_POSITION = p.ID) A, " + \
"(select G.ID_WORKER, D.ID_SITE, D.NUM_SITE, D.NUM_WEEK, D.NUM_YEAR " + \
"from ASSIGNMENT G, (select B.ID_SITE, B.NUM_SITE, C.NUM_WEEK, C.NUM_YEAR, C.ID_PHASE " + \
"from (select SITE.ID as ID_SITE, SITE.NUM_SITE " + \
"from SITE " + \
"""where "$dateInit" >= SITE.DATE_INIT and "$dateEnd" <= SITE.DATE_END) B, """ + \
"(select PHASE.ID as ID_PHASE, PHASE.NUM_WEEK, PHASE.NUM_YEAR, PHASE.ID_SITE " + \
"from PHASE " + \
"where $numYearInit <= PHASE.NUM_YEAR and $numYearEnd >= PHASE.NUM_YEAR " + \
"and $numWeekInit <= PHASE.NUM_WEEK and $numWeekEnd >= PHASE.NUM_WEEK) C ) D " + \
"where G.ID_PHASE = D.ID_PHASE) E " + \
"where A.ID_WORKER = E.ID_WORKER")
from isoweek import Week
d1 = Week(numYearInit, numWeekInit).monday()
d2 = Week(numYearEnd, numWeekEnd).monday()
# Construit la requête SQL
request = TEMPLATE_WHERE_NAT.substitute(dateInit = d1.isoformat(), dateEnd = d2.isoformat(), numYearInit = numYearInit, numYearEnd = numYearEnd, numWeekInit = numWeekInit, numWeekEnd = numWeekEnd)
if self._verboseMode:
(request)
cursor = co[1]
# execution d'une requete
cursor.execute(request)
o = cursor.fetchall()
if o != None:
# construit et retourne un Objet du Systeme
res = set()
for x in o:
if self._verboseMode:
print(x)
res.add(self._buildObject(co, x))
return res
else:
return None
def __call__(self, wizard, form, step, data, files):
cart_data = wizard.get_cleaned_data_for_step('cart') or {}
form.thematic = get_thematic(cart_data)
if form.thematic:
for k, f in [('size', form.thematic.size),
('carrier', form.thematic.carrier),
('frequency', form.thematic.frequency),
('start', form.thematic.start_duration)]:
if f: form.fields[k].initial = f
if form.thematic.end_duration:
delta = relativedelta(Week.fromstring(form.thematic.end_duration).day(1),
Week.fromstring(form.thematic.start_duration).day(1))
form.fields['duration'].initial = delta.months
if form.thematic.criterias:
__key = 'thematic_criterias_%d' % form.thematic.id
form.fields['criterias'].initial = cache.get(__key) or [v.id for v in form.thematic.criterias.all()]
if not cache.get(__key): cache.set(__key, form.fields['criterias'].initial)
form.fields['receive_only_once'].initial = form.thematic.receive_only_once
form.fields['customized'].initial = False
for field, locked in [('size', form.thematic.locked_size),
('carrier', form.thematic.locked_carrier),
('receive_only_once', form.thematic.locked_receive_only_once),
('frequency', form.thematic.locked_frequency),
('start', form.thematic.locked_start),
('duration', form.thematic.locked_duration),
('criterias', form.thematic.locked_criterias),
('customized', form.thematic.locked_products)]:
if locked:
attrs = form.fields[field].widget.attrs
attrs['class'] = attrs.get('class', '') + ' disabled'
else:
form.fields['customized'].initial = True
attrs = form.fields['customized'].widget.attrs
attrs['class'] = attrs.get('class', '') + ' disabled'
form.carriers = cache.get('create_carriers') or models.Carrier.objects.select_related().all()
if not cache.get('create_carriers'): cache.set('create_carriers', form.carriers)
form.sizes = cache.get('create_sizes') or models.Size.objects.select_related().order_by('order').all()
if not cache.get('create_sizes'): cache.set('create_sizes', form.sizes)
return form
def calculate_weekly_sales(item_collection_ids, user_tz, year):
"""
Calculates sales per week for items in the given set of item_collection_ids in a given year,
in the user's timezone.
"""
ordered_week_sales = OrderedDict()
for year_week in Week.weeks_of_year(year):
ordered_week_sales[year_week.week] = 0
start_at = isoweek_datetime(year, 1, user_tz)
end_at = isoweek_datetime(year + 1, 1, user_tz)
week_sales = db.session.query('sales_week', 'sum').from_statement(db.text('''
SELECT EXTRACT(WEEK FROM ordered_at AT TIME ZONE 'UTC' AT TIME ZONE :timezone)
AS sales_week, SUM(final_amount) AS sum
FROM line_item INNER JOIN item on line_item.item_id = item.id
WHERE status IN :statuses AND item_collection_id IN :item_collection_ids
AND ordered_at AT TIME ZONE 'UTC' AT TIME ZONE :timezone >= :start_at
AND ordered_at AT TIME ZONE 'UTC' AT TIME ZONE :timezone < :end_at
GROUP BY sales_week ORDER BY sales_week;
''')).params(timezone=user_tz, statuses=tuple([LINE_ITEM_STATUS.CONFIRMED, LINE_ITEM_STATUS.CANCELLED]),
start_at=start_at, end_at=end_at, item_collection_ids=tuple(item_collection_ids)).all()
for week_sale in week_sales:
ordered_week_sales[int(week_sale.sales_week)] = week_sale.sum
return ordered_week_sales
def week(self):
'Returns the start, end-tuple for a week around self.timestamp'
w = Week.withdate(self.timestamp)
start = clean_day(local_timezone.localize(datetime.combine(w.monday(), datetime.min.time())))
end = start + timedelta(days=6, hours=23, minutes=59, seconds=59)
return (start, end)
def decide_time(timeby,value):
if timeby == "Daily":
d = "2014"+value[4:]
start = parse(d)-timedelta(days=3)
elif timeby == "Weekly":
d = Week(2011, 40).monday()
s = d.strftime("%Y-%m-%d")
d = "2014"+s[4:]
start = parse(d)-timedelta(days=21)
else:
d = get_first_date(value)
start = parse(d)-timedelta(days=90)
if start.year == 2013:
start = parse("2014-1-1")
return start
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
cw = Week.withdate(Week.thisweek().sunday() + relativedelta(days=9))
start = self.fields['start']
start_choices = [str(w + cw.week - 1) for w in Week.weeks_of_year(cw.year)]
start_date_choices = ['%s (%s %s)' % ((w + cw.week - 1).day(settings.DELIVERY_DAY_OF_WEEK).strftime('%d-%m-%Y'), _('Week'), (w + cw.week - 1).week) for w in Week.weeks_of_year(cw.year)]
start.choices = zip(start_choices, start_date_choices)
start.initial = cw
for field in ['size', 'frequency', 'duration', 'start']:
self.fields[field].widget.attrs['class'] = 'slidebar-select'
for field in ['criterias', 'receive_only_once']:
self.fields[field].widget.attrs['class'] = 'checkbox-select'
for field in ['carrier']:
self.fields[field].widget.attrs['class'] = 'radio-select'
def home(request, year=None, week=None):
if not year or not week:
# use previous week by default
week = Week.thisweek() - 1
else:
week = Week(int(year), int(week))
date_range = get_date_range(week)
# absolute worst titles
worst_titles = NewsItem.objects.filter(published__range=date_range, score__isnull=False).order_by('-score')[:5]
# worst sites on average
site_avg = Site.objects.filter(
newsitems__published__range=date_range,
newsitems__score__isnull=False
).annotate(
score=Avg('newsitems__score')
).order_by('-score')[:5]
# biggest percentage of bad titles
sites = Site.objects.filter(
newsitems__published__range=date_range,
newsitems__score__isnull=False
).annotate(
bad=Sum(Case(When(newsitems__score__gt=1.0, then=1), output_field=IntegerField())),
total=Count('newsitems__score'),
)
percentages = []
# calculate percentages
for site in sites:
bad = float(site.bad if site.bad else 0)
total = float(site.total if site.total else 0)
percentage = int((bad/total)*100)
percentages.append((percentage, site))
# sort by percentage and take top 5
percentages = list(reversed(sorted(percentages, key=lambda x: x[0])))[:5]
context = {
'worst_titles': worst_titles,
'site_avg': site_avg,
'bad_percentages': percentages,
'date_range': {
'week': week,
'start': date_range[0].date(),
'end': date_range[1].date(),
}
}
return render(request, 'home.html', context)
def get_yw(str_date, date_format='%Y-%m-%d'):
"""
get week number within a year, from week 0 to week 52
:param str_date:
:param date_format:
:return:
"""
date_str = change_format(str_date, in_format=date_format, out_format='%Y-%m-%d')
date_obj = datetime.strptime(date_str, '%Y-%m-%d')
w = Week.withdate(date(date_obj.year, date_obj.month, date_obj.day))
return str(w[0]) + '-' + str(w[1] if w[1] > 9 else '0' + str(w[1])) # yyyy-ww
def __call__(self, wizard, own_data, form_data, tmp_dict):
# print('subscription done')
# print(tmp_dict)
user = get_user(wizard)
customer = user.customer
thematic = get_thematic(form_data['cart'])
customized = own_data.get('customized', False)
duration = int(own_data.get('duration'))
bw = Week.fromstring(own_data.get('start'))
ew = Week.withdate( bw.day(1) + relativedelta(months=duration) )
subscription = models.Subscription.objects.create(customer=customer, size=own_data['size'], carrier=own_data['carrier'], receive_only_once=own_data['receive_only_once'], frequency=int(own_data['frequency']), start=bw, end=ew, comment=form_data['comment'].get('comment', ''))
subscription.criterias = own_data['criterias']
if thematic and not customized:
for e in thematic.thematicextent_set.all():
subscription.extent_set.create(product=e.product, extent=e.extent, customized=False)
subscription.create_deliveries()
tmp_dict['subscription'] = subscription
deliveries = subscription.delivery_set.order_by('date')
mm.Message.objects.create_message(participants=[customer], subject=_('Votre abonnement %(subscription_id)d a été crée') % {'subscription_id': subscription.id}, body=_(
"""Bonjour %(name)s,
Nous sommes heureux de vous annoncer que votre abonnement %(subscription_id)d a été crée, il est accessible à l'adresse suivante :
http://www.vegeclic.fr/carts/subscriptions/%(subscription_id)d/deliveries/
Bien cordialement,
Végéclic.
"""
) % {'name': customer.main_address.__unicode__() if customer.main_address else '', 'date': deliveries[0].get_date_display(), 'subscription_id': subscription.id})
return True
def get_year_ago(self, dia=None, yearsago=None):
if not dia:
dia = self.day_present
years_ago = self.years_ago
if yearsago:
years_ago = int(yearsago)
logger.debug("Calculating {} year ago for {}".format(years_ago, dia))
current = dia.isocalendar() # 0 year, 1 week, 2, weekday
year = current[0]
week = current[1]
weekday = current[2] - 1 # Isocalendar uses american weekdays
week_current = Week(year, week)
week_past = week_current.replace(year - years_ago, week)
past_new = self.ensure_same_day_scenario(
week_current, week_past, weekday)
if past_new:
self.day_year_ago = datetime.combine(past_new, datetime.min.time())
else:
self.day_year_ago = datetime.combine(
week_past.day(weekday), datetime.min.time())
logger.debug("SUMMARY")
logger.debug(" - Present day: {}".format(week_current.day(weekday)))
logger.debug(" - Past day ini: {}".format(week_past.day(weekday)))
logger.debug(
" - Past day correction: {}".format(self.day_year_ago.strftime("%Y-%m-%d")))
logger.info("{} year ago from {} was {}" .format(years_ago, self.day_present.strftime(
"%Y-%m-%d"), self.day_year_ago.strftime("%Y-%m-%d")))
return self.day_year_ago
def __call__(self, wizard, form, step, data, files):
subscription_data = wizard.get_cleaned_data_for_step('subscription') or {}
if not subscription_data: return form
user = get_user(wizard)
if user:
form.balance = user.customer.wallet.balance_in_target_currency()
form.balance_inversed = form.balance*-1
form.currency = user.customer.wallet.target_currency
form.receive_only_once = subscription_data.get('receive_only_once')
form.price = subscription_data.get('size').default_price()
form.price_rate = 1+settings.DEGRESSIVE_PRICE_RATE/100
bw = Week.fromstring(str(subscription_data.get('start')))
ew = Week.withdate( bw.day(1) + relativedelta(months=int(subscription_data.get('duration'))) )
deliveries, prices = get_deliveries_from_subscription(subscription_data)
form.fields['nb_deliveries'].choices = [(k+1, '%d %s' % (k+1, _('échéance(s)'))) for k in range(len(prices))]
return form
def weekly_incidents(inc):
"""
:param team:
:return:
"""
open_week = Week.withdate(dt.datetime.strptime(inc['opened_at'], '%Y-%m-%d %H:%M:%S').date())
if open_week in incs_by_week.keys():
incs_by_week[open_week] += 1
incs_by_week.update({open_week: incs_by_week[open_week]})
else:
incs_by_week[open_week] = 1
