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 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 _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')