def test_leaves_timezones(self):
self.env.user.tz = 'US/Alaska' # UTC-9
def to_tuple(interval):
return (interval.start_datetime, interval.end_datetime)
# Here we test if the leaves are correctly computed in the case our user is in tz Alaska
# NB: Beware of winter/spring time
work_no_tz = [
to_tuple(x) for x in self.calendar._get_day_leave_intervals(
Date.from_string('2018-12-25'), time(0), time(23, 59, 59),
self.resource1_id)
]
self.assertEqual(work_no_tz[0],
(Datetime.from_string('2018-12-25 17:00:00'),
Datetime.from_string('2018-12-26 01:00:00')))
work_user_tz = [
to_tuple(x) for x in self.calendar._get_day_leave_intervals(
Date.from_string('2018-05-01'), time(0), time(23, 59, 59),
self.resource1_id)
]
self.assertEqual(work_user_tz[0],
(Datetime.from_string('2018-05-01 16:00:00'),
Datetime.from_string('2018-05-02 00:00:00')))
work_spec = [
to_tuple(x) for x in self.calendar._get_day_leave_intervals(
Date.from_string('2018-04-06'), time(0), time(23, 59, 59),
self.resource1_id)
]
self.assertEqual(work_spec[0],
(Datetime.from_string('2018-04-06 16:00:00'),
Datetime.from_string('2018-04-06 21:00:00')))
def test_calendar_working_day_intervals_leaves_generic(self):
# Test: day0 with leaves outside range: 1 interval
intervals = self.calendar._get_day_work_intervals(
Date.from_string('2013-02-12'),
start_time=time(7, 0, 0),
compute_leaves=True)
self.assertEqual(len(intervals), 1)
self.assertEqual(intervals[0][:2],
(Datetime.from_string('2013-02-12 08:00:00'),
Datetime.from_string('2013-02-12 16:00:00')))
# Test: day0 with leaves: 2 intervals because of leave between 9 and 12, ending at 15:45:30
intervals = self.calendar._get_day_work_intervals(
Date.from_string('2013-02-19'),
start_time=time(8, 15, 0),
end_time=time(15, 45, 30),
compute_leaves=True)
self.assertEqual(len(intervals), 2)
self.assertEqual(intervals[0][:2],
(Datetime.from_string('2013-02-19 08:15:00'),
Datetime.from_string('2013-02-19 09:00:00')))
self.assertEqual(intervals[1][:2],
(Datetime.from_string('2013-02-19 12:00:00'),
Datetime.from_string('2013-02-19 15:45:30')))
self.assertEqual(intervals[0][2]['attendances'], self.att_1)
self.assertEqual(intervals[0][2]['leaves'], self.leave1)
self.assertEqual(intervals[1][2]['attendances'], self.att_1)
self.assertEqual(intervals[0][2]['leaves'], self.leave1)
def test_calendar_work_days_intervals_timezone(self):
# _get_day_work_intervals converts from the timezone
# of the user into UTC
self.env.user.tz = 'US/Alaska'
(self.leave1 | self.leave2 | self.leave3).unlink()
leave = self.env['resource.calendar.leaves'].create({
'name': 'Timezoned Leaves',
'calendar_id': self.calendar.id,
'resource_id': self.resource1_id,
'date_from': to_naive_utc(Datetime.from_string('2013-02-21 10:00:00'), self.env.user),
'date_to': to_naive_utc(Datetime.from_string('2013-02-26 12:00:00'), self.env.user)
})
def to_tuple(interval):
return (interval.start_datetime, interval.end_datetime)
intervals = self.calendar._get_day_work_intervals(Date.from_string('2013-02-26'), time(10), time(18), False, self.resource1_id)
self.assertEqual(to_tuple(intervals[0]), (Datetime.from_string('2013-02-26 19:00:00'), Datetime.from_string('2013-02-27 01:00:00')))
intervals = self.calendar._get_day_work_intervals(Date.from_string('2013-02-26'), time(10), time(18), True, self.resource1_id)
self.assertEqual(to_tuple(intervals[0]), (Datetime.from_string('2013-02-26 21:00:00'), Datetime.from_string('2013-02-27 01:00:00')))
self.env.user.tz = 'Japan'
intervals = self.calendar._get_day_work_intervals(Date.from_string('2013-02-26'), time(10), time(18), False, self.resource1_id)
self.assertEqual(to_tuple(intervals[0]), (Datetime.from_string('2013-02-26 01:00:00'), Datetime.from_string('2013-02-26 07:00:00')))
intervals = self.calendar._get_day_work_intervals(Date.from_string('2013-02-26'), time(10), time(18), True, self.resource1_id)
self.assertEqual(to_tuple(intervals[0]), (Datetime.from_string('2013-02-26 03:00:00'), Datetime.from_string('2013-02-26 07:00:00')))
def test_leave(self):
def to_tuple(interval):
return (interval.start_datetime, interval.end_datetime)
# Here we test if the leaves are correctly computed in the case our user is in UTC
# NB: Beware of winter/spring time
work_no_tz = [
to_tuple(x) for x in self.calendar._get_day_leave_intervals(
Date.from_string('2018-12-25'), time(0), time(23, 59, 59),
self.resource1_id)
]
self.assertEqual(work_no_tz[0],
(Datetime.from_string('2018-12-25 08:00:00'),
Datetime.from_string('2018-12-25 16:00:00')))
work_user_tz = [
to_tuple(x) for x in self.calendar._get_day_leave_intervals(
Date.from_string('2018-05-01'), time(0), time(23, 59, 59),
self.resource1_id)
]
self.assertEqual(work_user_tz[0],
(Datetime.from_string('2018-05-01 08:00:00'),
Datetime.from_string('2018-05-01 16:00:00')))
work_spec = [
to_tuple(x) for x in self.calendar._get_day_leave_intervals(
Date.from_string('2018-04-06'), time(0), time(23, 59, 59),
self.resource1_id)
]
self.assertEqual(work_spec[0],
(Datetime.from_string('2018-04-06 08:00:00'),
Datetime.from_string('2018-04-06 13:00:00')))
def check_apply_plan(self, key, value, modulus, difference):
plan = self.env['medical.guard.plan'].create({
'location_id': self.center.id,
'product_id': self.product.id,
'start_time': 0,
'delay': 1,
'weekday': '*',
'monthday': '*',
'month': '*'
})
self.assertFalse(self.env['medical.guard'].search([
('plan_guard_id', '=', plan.id)
]))
plan.write({key: ((value+1) % modulus) + difference})
self.env['medical.guard.plan.apply'].create({
'start_date': Date.today(),
'end_date': Date.to_string(
Date.from_string(Date.today())),
}).run()
self.assertFalse(self.env['medical.guard'].search([
('plan_guard_id', '=', plan.id)
]))
plan.write({key: value})
self.env['medical.guard.plan.apply'].create({
'start_date': Date.today(),
'end_date': Date.to_string(
Date.from_string(Date.today())),
}).run()
self.assertTrue(self.env['medical.guard'].search([
('plan_guard_id', '=', plan.id)
]))
def check_apply_plan(self, key, value, modulus, difference):
plan = self.env["medical.guard.plan"].create(
{
"location_id": self.center.id,
"product_id": self.product.id,
"start_time": 0,
"delay": 1,
"weekday": "*",
"monthday": "*",
"month": "*",
}
)
self.assertFalse(
self.env["medical.guard"].search([("plan_guard_id", "=", plan.id)])
)
plan.write({key: ((value + 1) % modulus) + difference})
self.env["medical.guard.plan.apply"].create(
{
"start_date": Date.today(),
"end_date": Date.to_string(Date.from_string(Date.today())),
}
).run()
self.assertFalse(
self.env["medical.guard"].search([("plan_guard_id", "=", plan.id)])
)
plan.write({key: value})
self.env["medical.guard.plan.apply"].create(
{
"start_date": Date.today(),
"end_date": Date.to_string(Date.from_string(Date.today())),
}
).run()
self.assertTrue(
self.env["medical.guard"].search([("plan_guard_id", "=", plan.id)])
)
def test_calendar_working_day_intervals_no_leaves(self):
# Test: day0 without leaves: 1 interval
intervals = self.calendar._get_day_work_intervals(
Date.from_string('2013-02-12'), start_time=time(9, 8, 7))
self.assertEqual(len(intervals), 1)
self.assertEqual(intervals[0][:2],
(Datetime.from_string('2013-02-12 09:08:07'),
Datetime.from_string('2013-02-12 16:00:00')))
self.assertEqual(intervals[0][2]['attendances'], self.att_1)
# Test: day1, beginning at 10:30 -> work from 10:30 (arrival) until 16:00
intervals = self.calendar._get_day_work_intervals(
Date.from_string('2013-02-19'), start_time=time(10, 30, 0))
self.assertEqual(len(intervals), 1)
self.assertEqual(intervals[0][:2],
(Datetime.from_string('2013-02-19 10:30:00'),
Datetime.from_string('2013-02-19 16:00:00')))
self.assertEqual(intervals[0][2]['attendances'], self.att_1)
# Test: day3 without leaves: 2 interval
intervals = self.calendar._get_day_work_intervals(
Date.from_string('2013-02-15'), start_time=time(10, 11, 12))
self.assertEqual(len(intervals), 2)
self.assertEqual(intervals[0][:2],
(Datetime.from_string('2013-02-15 10:11:12'),
Datetime.from_string('2013-02-15 13:00:00')))
self.assertEqual(intervals[1][:2],
(Datetime.from_string('2013-02-15 16:00:00'),
Datetime.from_string('2013-02-15 23:00:00')))
self.assertEqual(intervals[0][2]['attendances'], self.att_2)
self.assertEqual(intervals[1][2]['attendances'], self.att_3)
def _get_archive_groups(
self,
model,
domain=None,
fields=None,
groupby="create_date",
order="create_date desc",
):
# TODO make without copy-pasting. Probably add ir.rule for portal user?
if not model:
return []
if domain is None:
domain = []
if fields is None:
fields = ["name", "create_date"]
groups = []
for group in (request.env[model].sudo()._read_group_raw(
domain, fields=fields, groupby=groupby, orderby=order)):
dates, label = group[groupby]
date_begin, date_end = dates.split("/")
groups.append({
"date_begin":
Date.to_string(Date.from_string(date_begin)),
"date_end":
Date.to_string(Date.from_string(date_end)),
"name":
label,
"item_count":
group[groupby + "_count"],
})
return groups
def _get_archive_groups(self,
model,
domain=None,
fields=None,
groupby="create_date",
order="create_date desc"):
if not model:
return []
if domain is None:
domain = []
if fields is None:
fields = ['name', 'create_date']
groups = []
for group in request.env[model]._read_group_raw(domain,
fields=fields,
groupby=groupby,
orderby=order):
dates, label = group[groupby]
date_begin, date_end = dates.split('/')
groups.append({
'date_begin':
Date.to_string(Date.from_string(date_begin)),
'date_end':
Date.to_string(Date.from_string(date_end)),
'name':
label,
'item_count':
group[groupby + '_count']
})
return groups
def test_02_account_move_date_range_fm_id_search(self):
january_2017_1st = Date.from_string('2017-01-01')
february_2017_1st = Date.from_string('2017-02-01')
march_2017_1st = Date.from_string('2017-03-01')
january_2018_1st = Date.from_string('2018-01-01')
move_jan_2017 = self.create_account_move(january_2017_1st)
move_feb_2017 = self.create_account_move(february_2017_1st)
move_march_2017 = self.create_account_move(march_2017_1st)
move_jan_2018 = self.create_account_move(january_2018_1st)
moves = self.AccountMoveObj.search([
('date_range_fm_id', 'ilike', 'January'),
])
self.assertTrue(all([
move_jan_2017 in moves,
move_feb_2017 not in moves,
move_march_2017 not in moves,
move_jan_2018 in moves,
]),
msg="There should be only moves in January")
moves = self.AccountMoveObj.search([
('date_range_fm_id', 'ilike', '2017'),
])
self.assertTrue(
all([
move_jan_2017 in moves,
move_feb_2017 in moves,
move_march_2017 not in moves,
move_jan_2018 not in moves,
]))
moves = self.AccountMoveObj.search([
('date_range_fm_id', '=', self.date_range_january_2017.id),
])
self.assertTrue(
all([
move_jan_2017 in moves,
move_feb_2017 not in moves,
move_march_2017 not in moves,
move_jan_2018 not in moves,
]))
moves = self.AccountMoveObj.search([
('date_range_fm_id', 'in', (self.date_range_january_2017.id,
self.date_range_february_2017.id)),
])
self.assertTrue(
all([
move_jan_2017 in moves,
move_feb_2017 in moves,
move_march_2017 not in moves,
move_jan_2018 not in moves,
]))
def read_group(self,
domain,
fields,
groupby,
offset=0,
limit=None,
orderby=False,
lazy=True):
"""Override read_group to perform pro-rata temporis adjustments.
When read_group is invoked with a domain that filters on
a time period (date >= from and date <= to, or
date_from <= to and date_to >= from), adjust the accumulated
values pro-rata temporis.
"""
date_from = None
date_to = None
assert isinstance(domain, list)
for domain_item in domain:
if isinstance(domain_item, (list, tuple)):
field, op, value = domain_item
if field == "date" and op == ">=":
date_from = value
elif field == "date_to" and op == ">=":
date_from = value
elif field == "date" and op == "<=":
date_to = value
elif field == "date_from" and op == "<=":
date_to = value
if (date_from is not None and date_to is not None
and not any(":" in f for f in fields)):
dt_from = Date.from_string(date_from)
dt_to = Date.from_string(date_to)
res = {}
sum_fields = set(fields) - set(groupby)
read_fields = set(fields + ["date_from", "date_to"])
for item in self.search(domain).read(read_fields):
key = tuple(item[k] for k in groupby)
if key not in res:
res[key] = {k: item[k] for k in groupby}
res[key].update({k: 0.0 for k in sum_fields})
res_item = res[key]
for sum_field in sum_fields:
item_dt_from = Date.from_string(item["date_from"])
item_dt_to = Date.from_string(item["date_to"])
i_days, item_days = self._intersect_days(
item_dt_from, item_dt_to, dt_from, dt_to)
res_item[sum_field] += item[sum_field] * i_days / item_days
return res.values()
return super(ProRataReadGroupMixin, self).read_group(
domain,
fields,
groupby,
offset=offset,
limit=limit,
orderby=orderby,
lazy=lazy,
)
def _compute_age(self):
today = fDate.from_string(fDate.today())
for book in self.filtered('date_release'):
try:
delta = (today - fDate.from_string(book.date_release))
book.age_days = delta.days
except (IOError, OSError) as exc:
message = _('Unable to compute age days') % exc
raise UserError(message)
def fetch_dashboard_data(self, website_id, date_from, date_to):
datetime_from = datetime.combine(Date.from_string(date_from), time.min)
datetime_to = datetime.combine(Date.from_string(date_to), time.max)
results = super(WebsiteSaleLinkTrackerBackend,
self).fetch_dashboard_data(website_id, date_from,
date_to)
results['dashboards']['sales']['utm_graph'] = self.fetch_utm_data(
datetime_from, datetime_to)
return results
def test_leave(self):
def to_tuple(interval):
return (interval.start_datetime, interval.end_datetime)
# Here we test if the leaves are correctly computed in the case our user is in UTC
# NB: Beware of winter/spring time
work_no_tz = [to_tuple(x) for x in self.calendar._get_day_leave_intervals(Date.from_string('2018-12-25'), time(0), time(23, 59, 59), self.resource1_id)]
self.assertEqual(work_no_tz[0], (Datetime.from_string('2018-12-25 08:00:00'), Datetime.from_string('2018-12-25 16:00:00')))
work_user_tz = [to_tuple(x) for x in self.calendar._get_day_leave_intervals(Date.from_string('2018-05-01'), time(0), time(23, 59, 59), self.resource1_id)]
self.assertEqual(work_user_tz[0], (Datetime.from_string('2018-05-01 08:00:00'), Datetime.from_string('2018-05-01 16:00:00')))
work_spec = [to_tuple(x) for x in self.calendar._get_day_leave_intervals(Date.from_string('2018-04-06'), time(0), time(23, 59, 59), self.resource1_id)]
self.assertEqual(work_spec[0], (Datetime.from_string('2018-04-06 08:00:00'), Datetime.from_string('2018-04-06 13:00:00')))
def test_02_account_move_date_range_fy_id_search(self):
january_2017 = Date.from_string('2017-01-01')
january_2018 = Date.from_string('2018-01-01')
january_2019 = Date.from_string('2019-01-01')
move_2017 = self.create_account_move(january_2017)
move_2018 = self.create_account_move(january_2018)
move_2019 = self.create_account_move(january_2019)
moves = self.AccountMoveObj.search([
('date_range_fy_id', 'ilike', '2017'),
])
self.assertTrue(all([
move_2017 in moves,
move_2018 not in moves,
move_2019 not in moves,
]), msg="There should be only moves in 2017")
moves = self.AccountMoveObj.search([
('date_range_fy_id', '=', self.date_range_2017.id),
])
self.assertTrue(all([
move_2017 in moves,
move_2018 not in moves,
move_2019 not in moves,
]))
moves = self.AccountMoveObj.search([
('date_range_fy_id', 'in', (
self.date_range_2017.id,
self.date_range_2018.id
)),
])
self.assertTrue(all([
move_2017 in moves,
move_2018 in moves,
move_2019 not in moves,
]))
# Search non existing year
moves = self.AccountMoveObj.search([
('date_range_fy_id', 'ilike', '2016'),
])
self.assertFalse(
moves
)
def test_calendar_next_day(self):
# Test: next day: next day after day1 is day4
date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-12'))
self.assertEqual(date, self.date2.date())
# Test: next day: next day after day4 is (day1+7)
date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-15'))
self.assertEqual(date, self.date1.date() + relativedelta(days=7))
# Test: next day: next day after day4+1 is (day1+7)
date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-15') + relativedelta(days=1))
self.assertEqual(date, self.date1.date() + relativedelta(days=7))
# Test: next day: next day after day1-1 is day1
date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-12') + relativedelta(days=-1))
self.assertEqual(date, self.date1.date())
def test_calendar_previous_day(self):
# Test: previous day: previous day before day1 is (day4-7)
date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-12'))
self.assertEqual(date, self.date2.date() + relativedelta(days=-7))
# Test: previous day: previous day before day4 is day1
date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-15'))
self.assertEqual(date, self.date1.date())
# Test: previous day: previous day before day4+1 is day4
date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-15') + relativedelta(days=1))
self.assertEqual(date, self.date2.date())
# Test: previous day: previous day before day1-1 is (day4-7)
date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-12') + relativedelta(days=-1))
self.assertEqual(date, self.date2.date() + relativedelta(days=-7))
def test_calendar_previous_day(self):
# Test: previous day: previous day before day1 is (day4-7)
date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-12'))
self.assertEqual(date, self.date2.date() + relativedelta(days=-7))
# Test: previous day: previous day before day4 is day1
date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-15'))
self.assertEqual(date, self.date1.date())
# Test: previous day: previous day before day4+1 is day4
date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-15') + relativedelta(days=1))
self.assertEqual(date, self.date2.date())
# Test: previous day: previous day before day1-1 is (day4-7)
date = self.calendar._get_previous_work_day(day_date=Date.from_string('2013-02-12') + relativedelta(days=-1))
self.assertEqual(date, self.date2.date() + relativedelta(days=-7))
def test_calendar_next_day(self):
# Test: next day: next day after day1 is day4
date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-12'))
self.assertEqual(date, self.date2.date())
# Test: next day: next day after day4 is (day1+7)
date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-15'))
self.assertEqual(date, self.date1.date() + relativedelta(days=7))
# Test: next day: next day after day4+1 is (day1+7)
date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-15') + relativedelta(days=1))
self.assertEqual(date, self.date1.date() + relativedelta(days=7))
# Test: next day: next day after day1-1 is day1
date = self.calendar._get_next_work_day(day_date=Date.from_string('2013-02-12') + relativedelta(days=-1))
self.assertEqual(date, self.date1.date())
def setUp(self):
super(TestPartnerTimeToPay, self).setUp()
self.payment_model = self.env["account.payment"]
self.register_payments_model = self.env["account.payment.register"]
self.partner_id = self.env.ref("base.res_partner_1")
self.product_id = self.env.ref("product.product_product_4")
self.account_model = self.env["account.account"]
self.account_move_model = self.env["account.move"]
self.account_journal = self.env["account.journal"]
self.payment_method_manual_in = self.env.ref(
"account.account_payment_method_manual_in")
self.account_receivable_id = self.env.ref(
"account.data_account_type_receivable")
self.account_revenue_id = self.env.ref(
"account.data_account_type_revenue")
self.account_revenue = self.account_model.search(
[("user_type_id", "=", self.account_revenue_id.id)], limit=1)
self.today = Date.from_string(Date.context_today(self.env.user))
self.invoice_id = self.account_move_model.create({
"partner_id":
self.partner_id.id,
"type":
"out_invoice",
"invoice_date":
self.today,
"invoice_line_ids": [(
0,
0,
{
"product_id": self.product_id.id,
"name": self.product_id.name,
"price_unit": 100,
"quantity": 10,
"account_id": self.account_revenue.id,
},
)],
})
self.invoice_id._onchange_invoice_line_ids()
self.invoice_id._onchange_recompute_dynamic_lines()
self.invoice_id.action_post()
self.bank_journal_euro = self.account_journal.create({
"name": "Bank",
"type": "bank",
"code": "BNK67"
})
ctx = {
"active_model": "account.invoice",
"active_ids": [self.invoice_id.id]
}
self.register_payments = self.register_payments_model.with_context(
ctx).create({
"payment_date": self.today + relativedelta(days=10),
"journal_id": self.bank_journal_euro.id,
"payment_method_id": self.payment_method_manual_in.id,
})
self.register_payments.create_payments()
self.payment = self.payment_model.search([], order="id desc", limit=1)
def test_leaves_timezones(self):
self.env.user.tz = 'US/Alaska' # UTC-9
def to_tuple(interval):
return (interval.start_datetime, interval.end_datetime)
# Here we test if the leaves are correctly computed in the case our user is in tz Alaska
# NB: Beware of winter/spring time
work_no_tz = [to_tuple(x) for x in self.calendar._get_day_leave_intervals(Date.from_string('2018-12-25'), time(0), time(23, 59, 59), self.resource1_id)]
self.assertEqual(work_no_tz[0], (Datetime.from_string('2018-12-25 17:00:00'), Datetime.from_string('2018-12-26 01:00:00')))
work_user_tz = [to_tuple(x) for x in self.calendar._get_day_leave_intervals(Date.from_string('2018-05-01'), time(0), time(23, 59, 59), self.resource1_id)]
self.assertEqual(work_user_tz[0], (Datetime.from_string('2018-05-01 16:00:00'), Datetime.from_string('2018-05-02 00:00:00')))
work_spec = [to_tuple(x) for x in self.calendar._get_day_leave_intervals(Date.from_string('2018-04-06'), time(0), time(23, 59, 59), self.resource1_id)]
self.assertEqual(work_spec[0], (Datetime.from_string('2018-04-06 16:00:00'), Datetime.from_string('2018-04-06 21:00:00')))
def setUp(self):
super(TestPartnerTimeToPay, self).setUp()
self.payment_model = self.env['account.payment']
self.register_payments_model = self.env['account.register.payments']
self.partner_id = self.env.ref('base.res_partner_1')
self.product_id = self.env.ref('product.product_product_4')
self.account_model = self.env['account.account']
self.account_invoice_model = self.env['account.invoice']
self.account_journal = self.env['account.journal']
self.payment_method_manual_in =\
self.env.ref("account.account_payment_method_manual_in")
self.account_receivable_id =\
self.env.ref('account.data_account_type_receivable')
self.account_revenue_id =\
self.env.ref('account.data_account_type_revenue')
self.account_receivable = self.account_model.search(
[('user_type_id', '=', self.account_receivable_id.id)], limit=1)
self.account_revenue = self.account_model.search(
[('user_type_id', '=', self.account_revenue_id.id)], limit=1)
self.today = Date.from_string(Date.context_today(self.env.user))
self.invoice_id = self.account_invoice_model.create({
'partner_id': self.partner_id.id,
'type': 'out_invoice',
'account_id': self.account_receivable.id,
'date_invoice': self.today,
'invoice_line_ids': [(0, 0, {
'product_id': self.product_id.id,
'name': self.product_id.name,
'price_unit': 100,
'quantity': 10,
'account_id': self.account_revenue.id,
})]
})
self.invoice_id._onchange_invoice_line_ids()
self.invoice_id._onchange_cash_rounding()
self.invoice_id.action_invoice_open()
self.bank_journal_euro =\
self.account_journal.create({
'name': 'Bank',
'type': 'bank',
'code': 'BNK67'
})
ctx = {
'active_model': 'account.invoice',
'active_ids': [self.invoice_id.id]
}
self.register_payments =\
self.register_payments_model.with_context(ctx).create({
'payment_date':
self.today + relativedelta(days=10),
'journal_id': self.bank_journal_euro.id,
'payment_method_id': self.payment_method_manual_in.id,
})
self.register_payments.create_payments()
self.payment = self.payment_model.search([], order="id desc", limit=1)
def _compute_age(self):
today = fDate.from_string(fDate.today())
for lote in self.filtered('removal_date'):
fecha_vencimiento = dateutil.parser.parse(lote.removal_date).date()
# import pdb; pdb.set_trace()
delta = (fecha_vencimiento - today)
lote.dias_vencimiento = delta.days
def test_01_account_move_date_range_fy_id_compute(self):
january_1st = Date.from_string('2017-01-01')
move = self.create_account_move(january_1st)
self.assertEquals(
move.date_range_fy_id, self.date_range_2017,
msg="Move period should be 2017")
self.assertTrue(all([
line.date_range_fy_id == self.date_range_2017
for line in move.line_ids
]), msg="All lines period should be 2017")
january_2019 = Date.from_string('2019-01-01')
move = self.create_account_move(january_2019)
self.assertFalse(
bool(move.date_range_fy_id),
msg="Move shouldn't have any date range")
def search(self, date_from=None, date_to=None):
_logger.info("search from {} to {}".format(date_from, date_to))
domain = []
if date_from:
date_from = Date.from_string(date_from)
domain.append(("date", ">=", date_from))
if date_to:
date_to = Date.from_string(date_to)
domain.append(("date", "<=", date_to))
requests = self.env["subscription.request"].search(domain)
response = {
"count": len(requests),
"rows": [self._to_dict(sr) for sr in requests],
}
return response
def test_calendar_working_day_intervals_leaves_resource(self):
# Test: day1+14 on leave, with resource leave computation
intervals = self.calendar._get_day_work_intervals(
Date.from_string('2013-02-26'),
start_time=time(7, 0, 0),
compute_leaves=True,
resource_id=self.resource1_id)
# Result: nothing, because on leave
self.assertEqual(len(intervals), 0)
def test_calendar_working_day_intervals_leaves_generic(self):
# Test: day0 with leaves outside range: 1 interval
intervals = self.calendar._get_day_work_intervals(Date.from_string('2013-02-12'), start_time=time(7, 0, 0), compute_leaves=True)
self.assertEqual(len(intervals), 1)
self.assertEqual(intervals[0][:2], (Datetime.from_string('2013-02-12 08:00:00'), Datetime.from_string('2013-02-12 16:00:00')))
# Test: day0 with leaves: 2 intervals because of leave between 9 and 12, ending at 15:45:30
intervals = self.calendar._get_day_work_intervals(Date.from_string('2013-02-19'),
start_time=time(8, 15, 0),
end_time=time(15, 45, 30),
compute_leaves=True)
self.assertEqual(len(intervals), 2)
self.assertEqual(intervals[0][:2], (Datetime.from_string('2013-02-19 08:15:00'), Datetime.from_string('2013-02-19 09:00:00')))
self.assertEqual(intervals[1][:2], (Datetime.from_string('2013-02-19 12:00:00'), Datetime.from_string('2013-02-19 15:45:30')))
self.assertEqual(intervals[0][2]['attendances'], self.att_1)
self.assertEqual(intervals[0][2]['leaves'], self.leave1)
self.assertEqual(intervals[1][2]['attendances'], self.att_1)
self.assertEqual(intervals[0][2]['leaves'], self.leave1)
def _get_archive_groups(self, model, domain=None, fields=None, groupby="create_date", order="create_date desc"):
if not model:
return []
if domain is None:
domain = []
if fields is None:
fields = ['name', 'create_date']
groups = []
for group in request.env[model]._read_group_raw(domain, fields=fields, groupby=groupby, orderby=order):
dates, label = group[groupby]
date_begin, date_end = dates.split('/')
groups.append({
'date_begin': Date.to_string(Date.from_string(date_begin)),
'date_end': Date.to_string(Date.from_string(date_end)),
'name': label,
'item_count': group[groupby + '_count']
})
return groups
def _inverse_age(self):
today = fDate.from_string(fDate.context_today(self))
for book in self.filtered('date_release'):
try:
d = today - timedelta(days=book.age_days)
book.date_release = fDate.to_string(d)
except (IOError, OSError) as exc:
message = _('Unable to inverse age') % exc
raise UserError(message)
def _search_age(self, operator, value):
today = fDate.from_string(fDate.context_today(self))
value_days = timedelta(days=value)
value_date = fDate.to_string(today - value_days)
# convert the operator:
# book with age > value have a date < value_date
operator_map = {'>': '<', '>=': '<=', '<': '>', '<=': '>='}
new_op = operator_map.get(operator, operator)
return [('date_release', new_op, value_date)]
def test_complex_plan(self):
plan = self.env['medical.guard.plan'].create({
'location_id': self.center.id,
'product_id': self.product.id,
'start_time': 0,
'delay': 1,
'weekday': '*',
'monthday': '*',
'month': '*'
})
self.assertFalse(self.env['medical.guard'].search([
('plan_guard_id', '=', plan.id)
]))
plan.monthday = '1-40'
date = Date.from_string(Date.today()).replace(day=1)
with self.assertRaises(UserError):
self.env['medical.guard.plan.apply'].create({
'start_date': Date.to_string(date),
'end_date': Date.to_string(date + timedelta(days=1)),
}).run()
plan.monthday = '1%'
with self.assertRaises(UserError):
self.env['medical.guard.plan.apply'].create({
'start_date': Date.to_string(date),
'end_date': Date.to_string(date + timedelta(days=1)),
}).run()
plan.monthday = 'AB/2'
with self.assertRaises(UserError):
self.env['medical.guard.plan.apply'].create({
'start_date': Date.to_string(date),
'end_date': Date.to_string(date + timedelta(days=1)),
}).run()
plan.monthday = '*/2'
self.env['medical.guard.plan.apply'].create({
'start_date': Date.to_string(date + timedelta(days=1)),
'end_date': Date.to_string(date + timedelta(days=1)),
}).run()
self.assertFalse(self.env['medical.guard'].search([
('plan_guard_id', '=', plan.id)
]))
plan.monthday = '15-20'
self.env['medical.guard.plan.apply'].create({
'start_date': Date.to_string(date),
'end_date': Date.to_string(date + timedelta(days=1)),
}).run()
self.assertFalse(self.env['medical.guard'].search([
('plan_guard_id', '=', plan.id)
]))
plan.monthday = '15-5'
self.env['medical.guard.plan.apply'].create({
'start_date': Date.to_string(date),
'end_date': Date.to_string(date + timedelta(days=1)),
}).run()
self.assertTrue(self.env['medical.guard'].search([
('plan_guard_id', '=', plan.id)
]))
def test_calendar_working_day_intervals_leaves_resource(self):
# Test: day1+14 on leave, with resource leave computation
intervals = self.calendar._get_day_work_intervals(
Date.from_string('2013-02-26'),
start_time=time(7, 0, 0),
compute_leaves=True,
resource_id=self.resource1_id
)
# Result: nothing, because on leave
self.assertEqual(len(intervals), 0)
def _search_age(self, operator, value):
try:
today = fDate.from_string(fDate.context_today(self))
value_days = timedelta(days=value)
value_date = fDate.to_string(today - value_days)
operator_map = {'>': '<', '>=': '<=', '<': '>', '<=': '>=', }
new_op = operator_map.get(operator, operator)
return [('date_release', new_op, value_date)]
except (IOError, OSError) as exc:
message = _('Unable to search by age') % exc
raise UserError(message)
def _get_archive_groups(self, model, domain=None, fields=None, groupby="create_date", order="create_date desc"):
if not model:
return []
if domain is None:
domain = []
if fields is None:
fields = ["name", "create_date"]
groups = []
for group in request.env[model]._read_group_raw(domain, fields=fields, groupby=groupby, orderby=order):
dates, label = group[groupby]
date_begin, date_end = dates.split("/")
groups.append(
{
"date_begin": Date.to_string(Date.from_string(date_begin)),
"date_end": Date.to_string(Date.from_string(date_end)),
"name": label,
"item_count": group[groupby + "_count"],
}
)
return groups
def test_calendar_working_day_intervals_no_leaves(self):
# Test: day0 without leaves: 1 interval
intervals = self.calendar._get_day_work_intervals(Date.from_string('2013-02-12'), start_time=time(9, 8, 7))
self.assertEqual(len(intervals), 1)
self.assertEqual(intervals[0][:2], (Datetime.from_string('2013-02-12 09:08:07'), Datetime.from_string('2013-02-12 16:00:00')))
self.assertEqual(intervals[0][2]['attendances'], self.att_1)
# Test: day1, beginning at 10:30 -> work from 10:30 (arrival) until 16:00
intervals = self.calendar._get_day_work_intervals(Date.from_string('2013-02-19'), start_time=time(10, 30, 0))
self.assertEqual(len(intervals), 1)
self.assertEqual(intervals[0][:2], (Datetime.from_string('2013-02-19 10:30:00'), Datetime.from_string('2013-02-19 16:00:00')))
self.assertEqual(intervals[0][2]['attendances'], self.att_1)
# Test: day3 without leaves: 2 interval
intervals = self.calendar._get_day_work_intervals(Date.from_string('2013-02-15'), start_time=time(10, 11, 12))
self.assertEqual(len(intervals), 2)
self.assertEqual(intervals[0][:2], (Datetime.from_string('2013-02-15 10:11:12'), Datetime.from_string('2013-02-15 13:00:00')))
self.assertEqual(intervals[1][:2], (Datetime.from_string('2013-02-15 16:00:00'), Datetime.from_string('2013-02-15 23:00:00')))
self.assertEqual(intervals[0][2]['attendances'], self.att_2)
self.assertEqual(intervals[1][2]['attendances'], self.att_3)
def _get_archive_groups_sudo(
self,
model,
domain=None,
fields=None,
groupby="create_date",
order="create_date desc",
):
"""Same as the one from website_portal_v10 except that it runs
in root.
"""
if not model:
return []
if domain is None:
domain = []
if fields is None:
fields = ["name", "create_date"]
groups = []
for group in (request.env[model].sudo().read_group(domain,
fields=fields,
groupby=groupby,
orderby=order)):
label = group[groupby]
date_begin = date_end = None
for leaf in group["__domain"]:
if leaf[0] == groupby:
if leaf[1] == ">=":
date_begin = leaf[2]
elif leaf[1] == "<":
date_end = leaf[2]
groups.append({
"date_begin":
Date.to_string(Date.from_string(date_begin)),
"date_end":
Date.to_string(Date.from_string(date_end)),
"name":
label,
"item_count":
group[groupby + "_count"],
})
return groups
def test_01_account_move_date_range_fm_id_compute(self):
january_1st = Date.from_string("2017-01-01")
move = self.create_account_move(january_1st)
self.assertEqual(
move.date_range_fm_id,
self.date_range_january_2017,
msg="Move period should be January 2017",
)
self.assertTrue(
all([
line.date_range_fm_id == self.date_range_january_2017
for line in move.line_ids
]),
msg="All lines period should be January 2017",
)
march_1st = Date.from_string("2017-03-01")
move = self.create_account_move(march_1st)
self.assertFalse(bool(move.date_range_fm_id),
msg="Move shouldn't have any date range")
def test_contract_on_another_company(self):
""" Test that the work entry generation still work if
the contract is not on the same company than
the employee (Internal Use Case)
So when generating the work entries in Belgium,
there is an issue when accessing to the time off
in Hong Kong.
"""
company = self.env['res.company'].create({'name': 'Another Company'})
employee = self.env['hr.employee'].create({
'name': 'New Employee',
'company_id': company.id,
})
self.env['hr.contract'].create({
'name': 'Employee Contract',
'employee_id': employee.id,
'date_start': Date.from_string('2015-01-01'),
'state': 'open',
'company_id': self.env.ref('base.main_company').id,
'wage': 4000,
})
leave_type = self.env['hr.leave.type'].create({
'name': 'Sick',
'request_unit': 'hour',
'leave_validation_type': 'both',
'requires_allocation': 'no',
'company_id': company.id,
})
leave1 = self.env['hr.leave'].create({
'name': 'Sick 1 week during christmas snif',
'employee_id': employee.id,
'holiday_status_id': leave_type.id,
'date_from': Datetime.from_string('2019-12-23 06:00:00'),
'date_to': Datetime.from_string('2019-12-27 20:00:00'),
'number_of_days': 5,
})
leave1.action_approve()
leave1.action_validate()
# The work entries generation shouldn't raise an error
user = self.env['res.users'].create({
'name': 'Classic User',
'login': '******',
'company_id': self.env.ref('base.main_company').id,
'company_ids': self.env.ref('base.main_company').ids,
'groups_id': [(6, 0, [self.env.ref('hr_contract.group_hr_contract_manager').id, self.env.ref('base.group_user').id])],
})
self.env['hr.employee'].with_user(user).generate_work_entries('2019-12-01', '2019-12-31')
def test_sale_order_classification(self):
"""Generate classifications for diferent period slices"""
# This is the table of expected classifications according to the
# generated sales depending on the evaluated period:
# +------------+------+---+------+---+------+---+------+---+------+---+
# | From date | p1 | C | p2 | C | p3 | C | p4 | c | p5 | C |
# +------------+------+---+------+---+------+---+------+---+------+---+
# | 2021-01-01 | 4000 | C | 2000 | D | 6000 | B | 8000 | B | 5000 | B |
# | 2021-02-01 | 3000 | C | 0 | D | 6000 | B | 8000 | B | 0 | D |
# | 2021-03-01 | 2000 | D | 0 | D | 3000 | C | 4000 | C | 0 | D |
# | 2021-04-01 | 1000 | D | 0 | D | 3000 | C | 4000 | C | 0 | D |
# +------------+------+---+------+---+------+---+------+---+------+---+
company = self.env.user.company_id
cron_classify = self.env["product.product"].cron_sales_classification
# We want to ensure today's date to simplify the test
self.mock_date.today.return_value = Date.from_string("2021-04-01")
# We forced the products create date to 2021-03-01, so they won't be
# evaluated by the cron if set the days to ignore to 365
company.sale_classification_days_to_ignore = 365
cron_classify()
self.assertFalse(any(self.products.mapped("sale_classification")))
# Let's reset and now evaluate the a year from now to get all the sales
# which is the default for sale_classification_days_to_evaluate
company.sale_classification_days_to_ignore = 0
cron_classify()
product_classification = {
self.prod_1: "c",
self.prod_2: "d",
self.prod_3: "b",
self.prod_4: "b",
self.prod_5: "b",
}
self._test_product_classification(product_classification)
# 70 from now to get sales from february
company.sale_classification_days_to_evaluate = 70
cron_classify()
product_classification.update({self.prod_5: "d"})
self._test_product_classification(product_classification)
# 40 from now to get sales from march
company.sale_classification_days_to_evaluate = 40
cron_classify()
product_classification.update({
self.prod_1: "d",
self.prod_4: "c",
self.prod_3: "c",
})
self._test_product_classification(product_classification)
# Product 1 gets an A!
self._create_sale("2021-04-01", self.partner, self.prod_1, 20000)
cron_classify()
product_classification.update({self.prod_1: "a"})
self._test_product_classification(product_classification)
def test_account_budget(self):
# Creating a crossovered.budget record
budget = self.env["crossovered.budget"].create(
{
"date_from": Date.from_string("%s-01-01" % (datetime.datetime.now().year + 1)),
"date_to": Date.from_string("%s-12-31" % (datetime.datetime.now().year + 1)),
"name": "Budget %s" % (datetime.datetime.now().year + 1),
"state": "draft",
}
)
# I created two different budget lines
# Modifying a crossovered.budget record
self.env["crossovered.budget.lines"].create(
{
"crossovered_budget_id": budget.id,
"analytic_account_id": self.ref("analytic.analytic_partners_camp_to_camp"),
"date_from": Date.from_string("%s-01-01" % (datetime.datetime.now().year + 1)),
"date_to": Date.from_string("%s-12-31" % (datetime.datetime.now().year + 1)),
"general_budget_id": self.account_budget_post_purchase0.id,
"planned_amount": 10000.0,
}
)
self.env["crossovered.budget.lines"].create(
{
"crossovered_budget_id": budget.id,
"analytic_account_id": self.ref("analytic.analytic_our_super_product"),
"date_from": Date.from_string("%s-09-01" % (datetime.datetime.now().year + 1)),
"date_to": Date.from_string("%s-09-30" % (datetime.datetime.now().year + 1)),
"general_budget_id": self.account_budget_post_sales0.id,
"planned_amount": 400000.0,
}
)
# I check that Initially Budget is in "draft" state
self.assertEqual(budget.state, "draft")
# I pressed the confirm button to confirm the Budget
# Performing an action confirm on module crossovered.budget
budget.action_budget_confirm()
# I check that budget is in "Confirmed" state
self.assertEqual(budget.state, "confirm")
# I pressed the validate button to validate the Budget
# Performing an action validate on module crossovered.budget
budget.action_budget_validate()
# I check that budget is in "Validated" state
self.assertEqual(budget.state, "validate")
# I pressed the done button to set the Budget to "Done" state
# Performing an action done on module crossovered.budget
budget.action_budget_done()
# I check that budget is in "done" state
self.assertEqual(budget.state, "done")
def test_theoritical_amount_with_paid_date(self):
test_list = [
(str(datetime.now().year) + '-01-01', 0),
(str(datetime.now().year) + '-01-02', 0),
(str(datetime.now().year) + '-09-08', 0),
(str(datetime.now().year) + '-09-09', 0),
(str(datetime.now().year) + '-09-10', -364),
(str(self.last_day_of_budget.date()), -364),
]
for date, expected_amount in test_list:
_logger.info("Checking theoritical amount for the date: " + date)
self.mock_date.today.return_value = Date.from_string(date)
self.assertAlmostEqual(self.paid_date_line.theoritical_amount, expected_amount)
#invalidate the cache of the budget lines to recompute the theoritical amount at next iteration
self.paid_date_line.invalidate_cache()
def test_account_budget(self):
# Creating a crossovered.budget record
budget = self.env['crossovered.budget'].create({
'date_from': Date.from_string('%s-01-01' % (datetime.datetime.now().year + 1)),
'date_to': Date.from_string('%s-12-31' % (datetime.datetime.now().year + 1)),
'name': 'Budget %s' % (datetime.datetime.now().year + 1),
'state': 'draft'
})
# I created two different budget lines
# Modifying a crossovered.budget record
self.env['crossovered.budget.lines'].create({
'crossovered_budget_id': budget.id,
'analytic_account_id': self.ref('analytic.analytic_partners_camp_to_camp'),
'date_from': Date.from_string('%s-01-01' % (datetime.datetime.now().year + 1)),
'date_to': Date.from_string('%s-12-31' % (datetime.datetime.now().year + 1)),
'general_budget_id': self.account_budget_post_purchase0.id,
'planned_amount': 10000.0,
})
self.env['crossovered.budget.lines'].create({
'crossovered_budget_id': budget.id,
'analytic_account_id': self.ref('analytic.analytic_our_super_product'),
'date_from': Date.from_string('%s-09-01' % (datetime.datetime.now().year + 1)),
'date_to': Date.from_string('%s-09-30' % (datetime.datetime.now().year + 1)),
'general_budget_id': self.account_budget_post_sales0.id,
'planned_amount': 400000.0,
})
# I check that Initially Budget is in "draft" state
self.assertEqual(budget.state, 'draft')
# I pressed the confirm button to confirm the Budget
# Performing an action confirm on module crossovered.budget
budget.action_budget_confirm()
# I check that budget is in "Confirmed" state
self.assertEqual(budget.state, 'confirm')
# I pressed the validate button to validate the Budget
# Performing an action validate on module crossovered.budget
budget.action_budget_validate()
# I check that budget is in "Validated" state
self.assertEqual(budget.state, 'validate')
# I pressed the done button to set the Budget to "Done" state
# Performing an action done on module crossovered.budget
budget.action_budget_done()
# I check that budget is in "done" state
self.assertEqual(budget.state, 'done')
def test_leaves_other(self):
# Here we test if setting the value to other has the effect intended
leave = self.calendar._get_day_leave_intervals(Date.from_string('2013-02-26'), time(0), time(23, 59, 59), self.resource1_id, [('time_type', '=', 'other')])
self.assertEqual(len(leave), 0, "When asking for other should ignore leaves")
leave = self.calendar._get_day_leave_intervals(Date.from_string('2013-02-15'), time(0), time(23, 59, 59), self.resource1_id, [('time_type', '=', 'other')])
self.assertEqual(len(leave), 2, "When asking for other should compute others")
def test_account_budget(self):
# In order to check account budget module in Odoo I created a budget with few budget positions
# Checking if the budgetary positions have accounts or not
if not self.account_budget_post_sales0.account_ids:
a_sale = self.env['account.account'].create({
'name': 'Product Sales - (test)',
'code': 'X2020',
'user_type_id': self.ref('account.data_account_type_revenue'),
'tag_ids': [(6, 0, [self.ref('account.account_tag_operating')])],
})
self.account_budget_post_sales0.write({'account_ids': [(6, 0, [a_sale.id])]})
if not self.account_budget_post_purchase0.account_ids:
a_expense = self.env['account.account'].create({
'name': 'Expense - (test)',
'code': 'X2120',
'user_type_id': self.ref('account.data_account_type_expenses'),
'tag_ids': [(6, 0, [self.ref('account.account_tag_operating')])],
})
self.account_budget_post_purchase0.write({'account_ids': [(6, 0, [a_expense.id])]})
# Creating a crossovered.budget record
budget = self.env['crossovered.budget'].create({
'date_from': Date.from_string('%s-01-01' % (datetime.datetime.now().year + 1)),
'date_to': Date.from_string('%s-12-31' % (datetime.datetime.now().year + 1)),
'name': 'Budget %s' % (datetime.datetime.now().year + 1),
'state': 'draft'
})
# I created two different budget lines
# Modifying a crossovered.budget record
self.env['crossovered.budget.lines'].create({
'crossovered_budget_id': budget.id,
'analytic_account_id': self.ref('analytic.analytic_partners_camp_to_camp'),
'date_from': Date.from_string('%s-01-01' % (datetime.datetime.now().year + 1)),
'date_to': Date.from_string('%s-12-31' % (datetime.datetime.now().year + 1)),
'general_budget_id': self.account_budget_post_purchase0.id,
'planned_amount': 10000.0,
})
self.env['crossovered.budget.lines'].create({
'crossovered_budget_id': budget.id,
'analytic_account_id': self.ref('analytic.analytic_our_super_product'),
'date_from': Date.from_string('%s-09-01' % (datetime.datetime.now().year + 1)),
'date_to': Date.from_string('%s-09-30' % (datetime.datetime.now().year + 1)),
'general_budget_id': self.account_budget_post_sales0.id,
'planned_amount': 400000.0,
})
# I check that Initially Budget is in "draft" state
self.assertEqual(budget.state, 'draft')
# I pressed the confirm button to confirm the Budget
# Performing a workflow action confirm on module crossovered.budget
budget.signal_workflow('confirm')
# I check that budget is in "Confirmed" state
self.assertEqual(budget.state, 'confirm')
# I pressed the validate button to validate the Budget
# Performing a workflow action validate on module crossovered.budget
budget.signal_workflow('validate')
# I check that budget is in "Validated" state
self.assertEqual(budget.state, 'validate')
# I pressed the done button to set the Budget to "Done" state
# Performing a workflow action done on module crossovered.budget
budget.signal_workflow('done')
# I check that budget is in "done" state
self.assertEqual(budget.state, 'done')
