def test_event_date_range(self): self.patcher = patch( 'flectra.addons.event.models.event.fields.Datetime', wraps=Datetime) self.mock_datetime = self.patcher.start() self.mock_datetime.now.return_value = Datetime.to_string( datetime.datetime(2015, 12, 31, 12, 0)) self.event_0.registration_ids.event_begin_date = datetime.datetime( 2015, 12, 31, 18, 0) self.assertEqual(self.event_0.registration_ids.get_date_range_str(), u'today') self.event_0.registration_ids.event_begin_date = datetime.datetime( 2016, 1, 1, 6, 0) self.assertEqual(self.event_0.registration_ids.get_date_range_str(), u'tomorrow') self.event_0.registration_ids.event_begin_date = datetime.datetime( 2016, 1, 2, 6, 0) self.assertEqual(self.event_0.registration_ids.get_date_range_str(), u'in 2 days') self.mock_datetime.now.return_value = Datetime.to_string( datetime.datetime(2015, 12, 10, 12, 0)) self.event_0.registration_ids.event_begin_date = datetime.datetime( 2016, 1, 25, 6, 0) self.assertEqual(self.event_0.registration_ids.get_date_range_str(), u'next month') self.patcher.stop()
def test_event_configurator(self): event = self.env['event.event'].create({ 'name': 'Design Fair Los Angeles', 'date_begin': Datetime.now() + timedelta(days=1), 'date_end': Datetime.now() + timedelta(days=5), }) self.env['event.event.ticket'].create([{ 'name': 'Standard', 'event_id': event.id, 'product_id': self.env.ref('event_sale.product_product_event').id, }, { 'name': 'VIP', 'event_id': event.id, 'product_id': self.env.ref('event_sale.product_product_event').id, }]) self.start_tour("/web", 'event_configurator_tour', login="******")
def _interval_dates(self, frequency, company): """ Method used to compute the theoretical date from which account move lines should be fetched @param {string} frequency: a valid value of the selection field on the object (daily, monthly, annually) frequencies are literal (daily means 24 hours and so on) @param {recordset} company: the company for which the closing is done @return {dict} the theoretical date from which account move lines are fetched. date_stop date to which the move lines are fetched, always now() the dates are in their Flectra Database string representation """ date_stop = datetime.utcnow() interval_from = None name_interval = '' if frequency == 'daily': interval_from = date_stop - timedelta(days=1) name_interval = _('Daily Closing') elif frequency == 'monthly': month_target = date_stop.month > 1 and date_stop.month - 1 or 12 year_target = month_target < 12 and date_stop.year or date_stop.year - 1 interval_from = date_stop.replace(year=year_target, month=month_target) name_interval = _('Monthly Closing') elif frequency == 'annually': year_target = date_stop.year - 1 interval_from = date_stop.replace(year=year_target) name_interval = _('Annual Closing') return { 'interval_from': FieldDateTime.to_string(interval_from), 'date_stop': FieldDateTime.to_string(date_stop), 'name_interval': name_interval }
def test_calendar_timezone(self): # user in timezone UTC-9 asks for work hours # Limits: between 2013-02-19 10:00:00 and 2013-02-26 15:30:00 (User TZ) # between 2013-02-19 19:00:00 and 2013-02-27 00:30:00 (UTC) # Leaves: between 2013-02-21 10:00:00 and 2013-02-26 12:00:00 (User TZ) # res: 19/02 (10-16 (beginning)) + 22/02 (0 (leave)) + 26/02 (12-15.30 (leave+ending)) 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) }) res = self.calendar.get_work_hours_count( to_naive_utc(Datetime.from_string('2013-02-19 10:00:00'), self.env.user), to_naive_utc(Datetime.from_string('2013-02-26 15:30:00'), self.env.user), self.resource1_id, compute_leaves=True) self.assertEqual(res, 9.5)
def test_calendar_working_hours_of_date(self): # Test: day1, beginning at 10:30 -> work from 10:30 (arrival) until 16:00 wh = self.calendar.get_work_hours_count( Datetime.from_string('2013-02-19 10:30:00'), Datetime.from_string('2013-02-19 18:00:00'), self.resource1_id, compute_leaves=False) self.assertEqual(wh, 5.5)
def test_calendar_days_scheduling_timezone(self): self.env.user.tz = 'US/Alaska' res = self.calendar.plan_days( 5, to_naive_utc(Datetime.from_string('2013-02-12 09:08:07'), self.env.user)) self.assertEqual( to_naive_user_tz(res, self.env.user).date(), Datetime.from_string('2013-02-26 00:00:00').date())
def test_calendar_working_hours(self): # new API: resource without leaves # res: 2 weeks -> 40 hours res = self.calendar.get_work_hours_count( Datetime.from_string('2013-02-12 06:00:00'), Datetime.from_string('2013-02-22 23:00:00'), self.resource1_id, compute_leaves=False) self.assertEqual(res, 40.0)
def test_calendar_working_hours_leaves(self): # new API: resource and leaves # res: 2 weeks -> 40 hours - (3+4) leave hours res = self.calendar.get_work_hours_count( Datetime.from_string('2013-02-12 06:00:00'), Datetime.from_string('2013-02-22 23:00:00'), self.resource1_id, compute_leaves=True) self.assertEqual(res, 33.0)
def test_calendar_working_hours_count(self): calendar = self.env.ref('resource.resource_calendar_std_35h') res = calendar.get_work_hours_count( Datetime.from_string( '2017-05-03 14:03:00'), # Wednesday (8:00-12:00, 13:00-16:00) Datetime.from_string( '2017-05-04 11:03:00'), # Thursday (8:00-12:00, 13:00-16:00) resource_id=None, compute_leaves=False) self.assertEqual(res, 5.0)
def test_interval_and(self): self.assertEqual( self.env['resource.calendar']._interval_and( self.intervals[0], self.intervals[1]), self.calendar._interval_new( Datetime.from_string('2013-02-04 09:00:00'), Datetime.from_string('2013-02-04 11:00:00'))) self.assertEqual( self.env['resource.calendar']._interval_and( self.intervals[2], self.intervals[3]), None)
def ctx_tz(record, field): res_lang = None ctx = record._context tz_name = pytz.timezone(ctx.get('tz') or record.env.user.tz) timestamp = Datetime.from_string(record[field]) if ctx.get('lang'): res_lang = record.env['res.lang'].search([('code', '=', ctx['lang'])], limit=1) if res_lang: timestamp = pytz.utc.localize(timestamp, is_dst=False) return datetime.strftime(timestamp.astimezone(tz_name), res_lang.date_format + ' ' + res_lang.time_format) return Datetime.context_timestamp(record, timestamp)
def test_interval_remove(self): working_interval = self.calendar._interval_new( Datetime.from_string('2013-02-04 08:00:00'), Datetime.from_string('2013-02-04 18:00:00')) result = self.env['resource.calendar']._interval_remove_leaves( working_interval, self.intervals) self.assertEqual(len(result), 1) # First interval: 04, 14-17 self.assertEqual(result[0][:2], (Datetime.from_string('2013-02-04 14:00:00'), Datetime.from_string('2013-02-04 17:00:00')))
def test_calendar_hours_scheduling_timezone(self): # user in timezone UTC-9 asks for work hours self.env.user.tz = 'US/Alaska' res = self.calendar.plan_hours( 42, to_naive_utc(Datetime.from_string('2013-02-12 09:25:00'), self.env.user)) self.assertEqual( res, to_naive_utc(Datetime.from_string('2013-02-26 11:25:00'), self.env.user))
def poll(self, channels, last, options=None): if request.env.user.has_group('base.group_user'): ip_address = request.httprequest.remote_addr users_log = request.env['res.users.log'].search_count([ ('create_uid', '=', request.env.user.id), ('ip', '=', ip_address), ('create_date', '>=', Datetime.to_string(Datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)))]) if not users_log: with registry(request.env.cr.dbname).cursor() as cr: env = Environment(cr, request.env.user.id, {}) env['res.users.log'].create({'ip': ip_address}) return super(BusController, self).poll(channels, last, options=options)
def test_calendar_working_day_intervals_limited_attendances(self): """ Test attendances limited in time. """ attendance = self.env['resource.calendar.attendance'].search([ ('name', '=', 'Att3') ]) attendance.write({ 'date_from': self.date2 + relativedelta(days=7), 'date_to': False, }) intervals = self.calendar._get_day_work_intervals( self.date2.date(), start_time=self.date2.time()) self.assertEqual(len(intervals), 1) self.assertEqual(intervals[0][:2], (Datetime.from_string('2013-02-15 10:11:12'), Datetime.from_string('2013-02-15 13:00:00'))) attendance.write({ 'date_from': False, 'date_to': self.date2 - relativedelta(days=7), }) intervals = self.calendar._get_day_work_intervals( self.date2.date(), start_time=self.date2.time()) self.assertEqual(len(intervals), 1) self.assertEqual(intervals[0][:2], (Datetime.from_string('2013-02-15 10:11:12'), Datetime.from_string('2013-02-15 13:00:00'))) attendance.write({ 'date_from': self.date2 + relativedelta(days=7), 'date_to': self.date2 - relativedelta(days=7), }) intervals = self.calendar._get_day_work_intervals( self.date2.date(), start_time=self.date2.time()) self.assertEqual(len(intervals), 1) self.assertEqual(intervals[0][:2], (Datetime.from_string('2013-02-15 10:11:12'), Datetime.from_string('2013-02-15 13:00:00'))) attendance.write({ 'date_from': self.date2, 'date_to': self.date2, }) intervals = self.calendar._get_day_work_intervals( self.date2.date(), start_time=self.date2.time()) 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')))
def test_interval_schedule_hours(self): cleaned_intervals = self.env['resource.calendar']._interval_merge( self.intervals) result = self.env['resource.calendar']._interval_schedule_hours( cleaned_intervals, 5.5) self.assertEqual(len(result), 2) # First interval: 03, 8-10 untouched self.assertEqual(result[0][:2], (Datetime.from_string('2013-02-03 08:00:00'), Datetime.from_string('2013-02-03 10:00:00'))) # First interval: 04, 08-11:30 self.assertEqual(result[1][:2], (Datetime.from_string('2013-02-04 08:00:00'), Datetime.from_string('2013-02-04 11:30:00')))
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 test_in_date_5(self): """ Receive the same lot at different times, once they're in the same location, the quants are merged and only the earliest incoming date is kept. """ stock_location = self.env.ref('stock.stock_location_stock') product1 = self.env['product.product'].create({ 'name': 'Product A', 'type': 'product', 'tracking': 'lot', }) lot1 = self.env['stock.production.lot'].create({ 'name': 'lot1', 'product_id': product1.id, }) in_date1 = datetime.now() self.env['stock.quant']._update_available_quantity(product1, stock_location, 1.0, lot_id=lot1, in_date=in_date1) quant = self.env['stock.quant'].search([ ('product_id', '=', product1.id), ('location_id', '=', stock_location.id), ]) self.assertEqual(len(quant), 1) self.assertEqual(quant.quantity, 1) self.assertEqual(quant.lot_id.id, lot1.id) from flectra.fields import Datetime self.assertEqual(quant.in_date, Datetime.to_string(in_date1)) in_date2 = datetime.now() - timedelta(days=5) self.env['stock.quant']._update_available_quantity(product1, stock_location, 1.0, lot_id=lot1, in_date=in_date2) quant = self.env['stock.quant'].search([ ('product_id', '=', product1.id), ('location_id', '=', stock_location.id), ]) self.assertEqual(len(quant), 1) self.assertEqual(quant.quantity, 2) self.assertEqual(quant.lot_id.id, lot1.id) self.assertEqual(quant.in_date, Datetime.to_string(in_date2))
def test_event_configuration_from_type(self): """ In addition to event test, also test tickets configuration coming from event_sale capabilities. """ event_type = self.event_type_complex.with_user(self.env.user) event_type.write({ 'use_mail_schedule': False, 'use_ticket': False, }) self.assertEqual(event_type.event_type_ticket_ids, self.env['event.type.ticket']) event = self.env['event.event'].create({ 'name': 'Event Update Type', 'event_type_id': event_type.id, 'date_begin': FieldsDatetime.to_string(datetime.today() + timedelta(days=1)), 'date_end': FieldsDatetime.to_string(datetime.today() + timedelta(days=15)), }) self.assertEqual(event.event_ticket_ids, self.env['event.event.ticket']) event_type.write({ 'use_ticket': True, 'event_type_ticket_ids': [(5, 0), (0, 0, { 'name': 'First Ticket', 'product_id': self.event_product.id, 'seats_max': 5, })] }) self.assertEqual(event_type.event_type_ticket_ids.description, self.event_product.description_sale) # synchronize event event.write({'event_type_id': event_type.id}) self.assertEqual(event.event_ticket_ids.name, event.event_type_id.event_type_ticket_ids.name) self.assertTrue(event.event_ticket_ids.seats_limited) self.assertEqual(event.event_ticket_ids.seats_max, 5) self.assertEqual(event.event_ticket_ids.product_id, self.event_product) self.assertEqual(event.event_ticket_ids.price, self.event_product.list_price) self.assertEqual(event.event_ticket_ids.description, self.event_product.description_sale)
def _check_session_timing(self): self.ensure_one() date_today = datetime.utcnow() session_start = Datetime.from_string(self.start_at) if not date_today - timedelta(hours=24) <= session_start: raise UserError(_("This session has been opened another day. To comply with the French law, you should close sessions on a daily basis. Please close session %s and open a new one.", self.name)) return True
def _get_acquisition_date(self): self.ensure_one() return babel.dates.format_date( date=Datetime.from_string(self.acquisition_date), format='MMMM y', locale=self._context.get('lang') or 'en_US' )
def test_initial_data(self): """ Ensure initial data to avoid spaghetti test update afterwards """ self.assertFalse(self.lead_1.date_conversion) self.assertEqual(self.lead_1.date_open, Datetime.from_string('2020-01-15 11:30:00')) self.assertEqual(self.lead_1.user_id, self.user_sales_leads) self.assertEqual(self.lead_1.team_id, self.sales_team_1) self.assertEqual(self.lead_1.stage_id, self.stage_team1_1) self.assertEqual(self.lead_w_partner.stage_id, self.env['crm.stage']) self.assertEqual(self.lead_w_partner.user_id, self.user_sales_manager) self.assertEqual(self.lead_w_partner.team_id, self.sales_team_1) self.assertEqual(self.lead_w_partner_company.stage_id, self.stage_team1_1) self.assertEqual(self.lead_w_partner_company.user_id, self.user_sales_manager) self.assertEqual(self.lead_w_partner_company.team_id, self.sales_team_1) self.assertEqual(self.lead_w_contact.stage_id, self.stage_gen_1) self.assertEqual(self.lead_w_contact.user_id, self.user_sales_salesman) self.assertEqual(self.lead_w_contact.team_id, self.sales_team_convert) self.assertEqual(self.lead_w_email.stage_id, self.stage_gen_1) self.assertEqual(self.lead_w_email.user_id, self.user_sales_salesman) self.assertEqual(self.lead_w_email.team_id, self.sales_team_convert) self.assertEqual(self.lead_w_email_lost.stage_id, self.stage_team1_2) self.assertEqual(self.lead_w_email_lost.user_id, self.user_sales_leads) self.assertEqual(self.lead_w_email_lost.team_id, self.sales_team_1)
def test_lead_convert_batch_internals(self): """ Test internals of convert wizard, working in batch mode """ date = Datetime.from_string('2020-01-20 16:00:00') self.crm_lead_dt_mock.now.return_value = date lead_w_partner = self.lead_w_partner lead_w_contact = self.lead_w_contact lead_w_email_lost = self.lead_w_email_lost lead_w_email_lost.action_set_lost() self.assertEqual(lead_w_email_lost.active, False) convert = self.env['crm.lead2opportunity.partner'].with_context({ 'active_model': 'crm.lead', 'active_id': self.lead_1.id, 'active_ids': (self.lead_1 | lead_w_partner | lead_w_contact | lead_w_email_lost).ids, }).create({}) # test internals of convert wizard # self.assertEqual(convert.lead_id, self.lead_1) self.assertEqual(convert.user_id, self.lead_1.user_id) self.assertEqual(convert.team_id, self.lead_1.team_id) self.assertFalse(convert.partner_id) self.assertEqual(convert.name, 'convert') self.assertEqual(convert.action, 'create') convert.action_apply() self.assertEqual(convert.user_id, self.user_sales_leads) self.assertEqual(convert.team_id, self.sales_team_1) # lost leads are not converted (see crm_lead.convert_opportunity()) self.assertFalse(lead_w_email_lost.active) self.assertFalse(lead_w_email_lost.date_conversion) self.assertEqual(lead_w_email_lost.partner_id, self.env['res.partner']) self.assertEqual(lead_w_email_lost.stage_id, self.stage_team1_2) # did not change # other leads are converted into opportunities for opp in (self.lead_1 | lead_w_partner | lead_w_contact): # team management update: opportunity linked to chosen wizard values self.assertEqual(opp.type, 'opportunity') self.assertTrue(opp.active) self.assertEqual(opp.user_id, convert.user_id) self.assertEqual(opp.team_id, convert.team_id) # dates update: convert set them to now self.assertEqual(opp.date_open, date) self.assertEqual(opp.date_conversion, date) # stage update (depends on previous value) if opp == self.lead_1: self.assertEqual(opp.stage_id, self.stage_team1_1) # did not change elif opp == lead_w_partner: self.assertEqual(opp.stage_id, self.stage_team1_1 ) # is set to default stage of sales_team_1 elif opp == lead_w_contact: self.assertEqual(opp.stage_id, self.stage_gen_1) # did not change else: self.assertFalse(True)
def test_initial_data(self): """ Ensure initial data to avoid spaghetti test update afterwards """ self.assertFalse(self.lead_1.date_conversion) self.assertEqual(self.lead_1.date_open, Datetime.from_string('2020-01-15 11:30:00')) self.assertEqual(self.lead_1.user_id, self.user_sales_leads) self.assertEqual(self.lead_1.team_id, self.sales_team_1) self.assertEqual(self.lead_1.stage_id, self.stage_team1_1)
def test_event_seats(self): event_type = self.event_type_complex.with_user(self.env.user) event = self.env['event.event'].create({ 'name': 'Event Update Type', 'event_type_id': event_type.id, 'date_begin': FieldsDatetime.to_string(datetime.today() + timedelta(days=1)), 'date_end': FieldsDatetime.to_string(datetime.today() + timedelta(days=15)), }) self.assertEqual(event.address_id, self.env.user.company_id.partner_id) # seats: coming from event type configuration self.assertTrue(event.seats_limited) self.assertEqual(event.seats_available, event.event_type_id.seats_max) self.assertEqual(event.seats_unconfirmed, 0) self.assertEqual(event.seats_reserved, 0) self.assertEqual(event.seats_used, 0) self.assertEqual(event.seats_expected, 0) # create registration in order to check the seats computation self.assertTrue(event.auto_confirm) for x in range(5): reg = self.env['event.registration'].create({ 'event_id': event.id, 'name': 'reg_open', }) self.assertEqual(reg.state, 'open') reg_draft = self.env['event.registration'].create({ 'event_id': event.id, 'name': 'reg_draft', }) reg_draft.write({'state': 'draft'}) reg_done = self.env['event.registration'].create({ 'event_id': event.id, 'name': 'reg_done', }) reg_done.write({'state': 'done'}) self.assertEqual(event.seats_available, event.event_type_id.seats_max - 6) self.assertEqual(event.seats_unconfirmed, 1) self.assertEqual(event.seats_reserved, 5) self.assertEqual(event.seats_used, 1) self.assertEqual(event.seats_expected, 7)
def test_in_date_5(self): """ Receive the same lot at different times, once they're in the same location, the quants are merged and only the earliest incoming date is kept. """ lot1 = self.env['stock.production.lot'].create({ 'name': 'lot1', 'product_id': self.product_lot.id, 'company_id': self.env.company.id, }) from flectra.fields import Datetime in_date1 = Datetime.now() self.env['stock.quant']._update_available_quantity(self.product_lot, self.stock_location, 1.0, lot_id=lot1, in_date=in_date1) quant = self.env['stock.quant'].search([ ('product_id', '=', self.product_lot.id), ('location_id', '=', self.stock_location.id), ]) self.assertEqual(len(quant), 1) self.assertEqual(quant.quantity, 1) self.assertEqual(quant.lot_id.id, lot1.id) self.assertEqual(quant.in_date, in_date1) in_date2 = Datetime.now() - timedelta(days=5) self.env['stock.quant']._update_available_quantity(self.product_lot, self.stock_location, 1.0, lot_id=lot1, in_date=in_date2) quant = self.env['stock.quant'].search([ ('product_id', '=', self.product_lot.id), ('location_id', '=', self.stock_location.id), ]) self.assertEqual(len(quant), 1) self.assertEqual(quant.quantity, 2) self.assertEqual(quant.lot_id.id, lot1.id) self.assertEqual(quant.in_date, in_date2)
def _get_car_atn(self, acquisition_date, car_value, fuel_type, co2): # Compute the correction coefficient from the age of the car now = Datetime.from_string(Datetime.now()) start = Datetime.from_string(acquisition_date) if start: number_of_month = ( now.year - start.year) * 12.0 + now.month - start.month + int( bool(now.day - start.day + 1)) if number_of_month <= 12: age_coefficient = 1.00 elif number_of_month <= 24: age_coefficient = 0.94 elif number_of_month <= 36: age_coefficient = 0.88 elif number_of_month <= 48: age_coefficient = 0.82 elif number_of_month <= 60: age_coefficient = 0.76 else: age_coefficient = 0.70 car_value = car_value * age_coefficient # Compute atn value from corrected car_value magic_coeff = 6.0 / 7.0 # Don't ask me why if fuel_type == 'electric': atn = 0.0 else: if fuel_type in ['diesel', 'hybrid']: reference = 88.0 else: reference = 107.0 if not co2: co2 = 195 if fuel_type in ['diesel', 'hybrid'] else 205 if co2 <= reference: atn = car_value * max(0.04, (0.055 - 0.001 * (reference - co2))) * magic_coeff else: atn = car_value * min(0.18, (0.055 + 0.001 * (co2 - reference))) * magic_coeff return max(1310, atn) / 12.0
def test_calendar_working_hours_24(self): self.att_4 = self.env['resource.calendar.attendance'].create({ 'name': 'Att4', 'calendar_id': self.calendar.id, 'dayofweek': '2', 'hour_from': 0, 'hour_to': 24 }) res = self.calendar.get_work_hours_count( Datetime.from_string('2018-06-19 23:00:00'), Datetime.from_string('2018-06-21 01:00:00'), self.resource1_id, compute_leaves=True) self.assertAlmostEqual(res, 24.0)
def test_contract_transfer_leaves(self): def create_calendar_leave(start, end, resource=None): return self.env['resource.calendar.leaves'].create({ 'name': 'leave name', 'date_from': start, 'date_to': end, 'resource_id': resource.id if resource else None, 'calendar_id': self.employee.resource_calendar_id.id, 'time_type': 'leave', }) start = Datetime.to_datetime('2015-11-17 07:00:00') end = Datetime.to_datetime('2015-11-20 18:00:00') leave1 = create_calendar_leave(start, end, resource=self.employee.resource_id) start = Datetime.to_datetime('2015-11-25 07:00:00') end = Datetime.to_datetime('2015-11-28 18:00:00') leave2 = create_calendar_leave(start, end, resource=self.employee.resource_id) # global leave start = Datetime.to_datetime('2015-11-25 07:00:00') end = Datetime.to_datetime('2015-11-28 18:00:00') leave3 = create_calendar_leave(start, end) self.calendar_richard.transfer_leaves_to(self.calendar_35h, resources=self.employee.resource_id, from_date=Date.to_date('2015-11-21')) self.assertEqual(leave1.calendar_id, self.calendar_richard, "It should stay in Richard's calendar") self.assertEqual(leave3.calendar_id, self.calendar_richard, "Global leave should stay in original calendar") self.assertEqual(leave2.calendar_id, self.calendar_35h, "It should be transfered to the other calendar") # Transfer global leaves self.calendar_richard.transfer_leaves_to(self.calendar_35h, resources=None, from_date=Date.to_date('2015-11-21')) self.assertEqual(leave3.calendar_id, self.calendar_35h, "Global leave should be transfered")
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)