addons/resource/resource.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 from datetime import datetime, timedelta
  23 import math
  24 from faces import *
  25 from osv import fields, osv
  26 from tools.translate import _
  27
  28 from itertools import groupby
  29 from operator import itemgetter
  30
  31
  32 class resource_calendar(osv.osv):
  33     _name = "resource.calendar"
  34     _description = "Resource Calendar"
  35     _columns = {
  36         'name' : fields.char("Name", size=64, required=True),
  37         'company_id' : fields.many2one('res.company', 'Company', required=False),
  38         'attendance_ids' : fields.one2many('resource.calendar.attendance', 'calendar_id', 'Working Time'),
  39         'manager' : fields.many2one('res.users', 'Workgroup Manager'),
  40     }
  41     _defaults = {
  42         'company_id': lambda self, cr, uid, context: self.pool.get('res.company')._company_default_get(cr, uid, 'resource.calendar', context=context)
  43     }
  44
  45     def working_hours_on_day(self, cr, uid, resource_calendar_id, day, context=None):
  46         """Calculates the  Working Total Hours based on Resource Calendar and
  47         given working day (datetime object).
  48
  49         @param resource_calendar_id: resource.calendar browse record
  50         @param day: datetime object
  51
  52         @return: returns the working hours (as float) men should work on the given day if is in the attendance_ids of the resource_calendar_id (i.e if that day is a working day), returns 0.0 otherwise
  53         """
  54         res = 0.0
  55         for working_day in resource_calendar_id.attendance_ids:
  56             if (int(working_day.dayofweek) + 1) == day.isoweekday():
  57                 res += working_day.hour_to - working_day.hour_from
  58         return res
  59
  60     def _get_leaves(self, cr, uid, id, resource):
  61         """Private Method to Calculate resource Leaves days
  62
  63         @param id: resource calendar id
  64         @param resource: resource id for which leaves will ew calculated
  65
  66         @return : returns the list of dates, where resource on leave in
  67                   resource.calendar.leaves object (e.g.['%Y-%m-%d', '%Y-%m-%d'])
  68         """
  69         resource_cal_leaves = self.pool.get('resource.calendar.leaves')
  70         dt_leave = []
  71         resource_leave_ids = resource_cal_leaves.search(cr, uid, [('calendar_id','=',id), '|', ('resource_id','=',False), ('resource_id','=',resource)])
  72         #res_leaves = resource_cal_leaves.read(cr, uid, resource_leave_ids, ['date_from', 'date_to'])
  73         res_leaves = resource_cal_leaves.browse(cr, uid, resource_leave_ids)
  74
  75         for leave in res_leaves:
  76             dtf = datetime.strptime(leave.date_from, '%Y-%m-%d %H:%M:%S')
  77             dtt = datetime.strptime(leave.date_to, '%Y-%m-%d %H:%M:%S')
  78             no = dtt - dtf
  79             [dt_leave.append((dtf + timedelta(days=x)).strftime('%Y-%m-%d')) for x in range(int(no.days + 1))]
  80             dt_leave.sort()
  81
  82         return dt_leave
  83
  84     def interval_min_get(self, cr, uid, id, dt_from, hours, resource=False):
  85         """
  86         Calculates the working Schedule from supplied from date to till hours
  87         will be satisfied  based or resource calendar id. If resource is also
  88         given then it will consider the resource leave also and than will
  89         calculates resource working schedule
  90
  91         @param dt_from: datetime object, start of working scheduled
  92         @param hours: float, total number working  hours needed scheduled from
  93                       start date
  94         @param resource : Optional Resource id, if supplied than resource leaves
  95                         will also taken into consideration for calculating working
  96                         schedule.
  97         @return : List datetime object of working schedule based on supplies
  98                   params
  99         """
 100         if not id:
 101             td = int(hours)*3
 102             return [(dt_from - timedelta(hours=td), dt_from)]
 103         dt_leave = self._get_leaves(cr, uid, id, resource)
 104         dt_leave.reverse()
 105         todo = hours
 106         result = []
 107         maxrecur = 100
 108         current_hour = dt_from.hour
 109         while (todo>0) and maxrecur:
 110             cr.execute("select hour_from,hour_to from resource_calendar_attendance where dayofweek='%s' and calendar_id=%s order by hour_from desc", (dt_from.weekday(),id))
 111             for (hour_from,hour_to) in cr.fetchall():
 112                 leave_flag  = False
 113                 if (hour_from<current_hour) and (todo>0):
 114                     m = min(hour_to, current_hour)
 115                     if (m-hour_from)>todo:
 116                         hour_from = m-todo
 117                     dt_check = dt_from.strftime('%Y-%m-%d')
 118                     for leave in dt_leave:
 119                         if dt_check == leave:
 120                             dt_check = datetime.strptime(dt_check, '%Y-%m-%d') + timedelta(days=1)
 121                             leave_flag = True
 122                     if leave_flag:
 123                         break
 124                     else:
 125                         d1 = datetime(dt_from.year, dt_from.month, dt_from.day, int(math.floor(hour_from)), int((hour_from%1) * 60))
 126                         d2 = datetime(dt_from.year, dt_from.month, dt_from.day, int(math.floor(m)), int((m%1) * 60))
 127                         result.append((d1, d2))
 128                         current_hour = hour_from
 129                         todo -= (m-hour_from)
 130             dt_from -= timedelta(days=1)
 131             current_hour = 24
 132             maxrecur -= 1
 133         result.reverse()
 134         return result
 135
 136     # def interval_get(self, cr, uid, id, dt_from, hours, resource=False, byday=True):
 137     def interval_get_multi(self, cr, uid, date_and_hours_by_cal, resource=False, byday=True):
 138         def group(lst, key):
 139             lst.sort(key=itemgetter(key))
 140             grouped = groupby(lst, itemgetter(key))
 141             return dict([(k, [v for v in itr]) for k, itr in grouped])
 142         # END group
 143
 144         cr.execute("select calendar_id, dayofweek, hour_from, hour_to from resource_calendar_attendance order by hour_from")
 145         hour_res = cr.dictfetchall()
 146         hours_by_cal = group(hour_res, 'calendar_id')
 147
 148         results = {}
 149
 150         for d, hours, id in date_and_hours_by_cal:
 151             dt_from = datetime.strptime(d, '%Y-%m-%d %H:%M:%S')
 152             if not id:
 153                 td = int(hours)*3
 154                 results[(d, hours, id)] = [(dt_from, dt_from + timedelta(hours=td))]
 155                 continue
 156
 157             dt_leave = self._get_leaves(cr, uid, id, resource)
 158             todo = hours
 159             result = []
 160             maxrecur = 100
 161             current_hour = dt_from.hour
 162             while (todo>0) and maxrecur:
 163                 for (hour_from,hour_to) in [(item['hour_from'], item['hour_to']) for item in hours_by_cal[id] if item['dayofweek'] == str(dt_from.weekday())]:
 164                     leave_flag  = False
 165                     if (hour_to>current_hour) and (todo>0):
 166                         m = max(hour_from, current_hour)
 167                         if (hour_to-m)>todo:
 168                             hour_to = m+todo
 169                         dt_check = dt_from.strftime('%Y-%m-%d')
 170                         for leave in dt_leave:
 171                             if dt_check == leave:
 172                                 dt_check = datetime.strptime(dt_check, '%Y-%m-%d') + timedelta(days=1)
 173                                 leave_flag = True
 174                         if leave_flag:
 175                             break
 176                         else:
 177                             d1 = datetime(dt_from.year, dt_from.month, dt_from.day, int(math.floor(m)), int((m%1) * 60))
 178                             d2 = datetime(dt_from.year, dt_from.month, dt_from.day, int(math.floor(hour_to)), int((hour_to%1) * 60))
 179                             result.append((d1, d2))
 180                             current_hour = hour_to
 181                             todo -= (hour_to - m)
 182                 dt_from += timedelta(days=1)
 183                 current_hour = 0
 184                 maxrecur -= 1
 185             results[(d, hours, id)] = result
 186         return results
 187
 188     def interval_get(self, cr, uid, id, dt_from, hours, resource=False, byday=True):
 189         """Calculates Resource Working Internal Timing Based on Resource Calendar.
 190
 191         @param dt_from: start resource schedule calculation.
 192         @param hours : total number of working hours to be scheduled.
 193         @param resource: optional resource id, If supplied it will take care of
 194                          resource leave while scheduling.
 195         @param byday: boolean flag bit enforce day wise scheduling
 196
 197         @return :  list of scheduled working timing  based on resource calendar.
 198         """
 199         res = self.interval_get_multi(cr, uid, [(dt_from.strftime('%Y-%m-%d %H:%M:%S'), hours, id)], resource, byday)[(dt_from.strftime('%Y-%m-%d %H:%M:%S'), hours, id)]
 200         return res
 201
 202     def interval_hours_get(self, cr, uid, id, dt_from, dt_to, resource=False):
 203         """ Calculates the Total Working hours based on given start_date to
 204         end_date, If resource id is supplied that it will consider the source
 205         leaves also in calculating the hours.
 206
 207         @param dt_from : date start to calculate hours
 208         @param dt_end : date end to calculate hours
 209         @param resource: optional resource id, If given resource leave will be
 210                          considered.
 211
 212         @return : Total number of working hours based dt_from and dt_end and
 213                   resource if supplied.
 214         """
 215         if not id:
 216             return 0.0
 217         dt_leave = self._get_leaves(cr, uid, id, resource)
 218         hours = 0.0
 219
 220         current_hour = dt_from.hour
 221
 222         while (dt_from <= dt_to):
 223             cr.execute("select hour_from,hour_to from resource_calendar_attendance where dayofweek='%s' and calendar_id=%s order by hour_from", (dt_from.weekday(),id))
 224             der =  cr.fetchall()
 225             for (hour_from,hour_to) in der:
 226                 if hours != 0.0:#For first time of the loop only,hours will be 0
 227                     current_hour = hour_from
 228                 leave_flag = False
 229                 if (hour_to>=current_hour):
 230                     dt_check = dt_from.strftime('%Y-%m-%d')
 231                     for leave in dt_leave:
 232                         if dt_check == leave:
 233                             dt_check = datetime.strptime(dt_check, "%Y-%m-%d") + timedelta(days=1)
 234                             leave_flag = True
 235
 236                     if leave_flag:
 237                         break
 238                     else:
 239                         d1 = dt_from
 240                         d2 = datetime(dt_from.year, dt_from.month, dt_from.day, int(math.floor(hour_to)), int((hour_to%1) * 60))
 241
 242                         if hours != 0.0:#For first time of the loop only,hours will be 0
 243                             d1 = datetime(dt_from.year, dt_from.month, dt_from.day, int(math.floor(current_hour)), int((current_hour%1) * 60))
 244
 245                         if dt_from.day == dt_to.day:
 246                             if hour_from <= dt_to.hour <= hour_to:
 247                                 d2 = dt_to
 248                         dt_from = d2
 249                         hours += (d2-d1).seconds
 250             dt_from = datetime(dt_from.year, dt_from.month, dt_from.day, int(math.floor(current_hour)), int((current_hour%1) * 60)) + timedelta(days=1)
 251             current_hour = 0.0
 252
 253         return (hours/3600)
 254
 255 resource_calendar()
 256
 257 class resource_calendar_attendance(osv.osv):
 258     _name = "resource.calendar.attendance"
 259     _description = "Work Detail"
 260
 261     _columns = {
 262         'name' : fields.char("Name", size=64, required=True),
 263         'dayofweek': fields.selection([('0','Monday'),('1','Tuesday'),('2','Wednesday'),('3','Thursday'),('4','Friday'),('5','Saturday'),('6','Sunday')], 'Day of Week', required=True, select=True),
 264         'date_from' : fields.date('Starting Date'),
 265         'hour_from' : fields.float('Work from', required=True, help="Start and End time of working.", select=True),
 266         'hour_to' : fields.float("Work to", required=True),
 267         'calendar_id' : fields.many2one("resource.calendar", "Resource's Calendar", required=True),
 268     }
 269
 270     _order = 'dayofweek, hour_from'
 271
 272     _defaults = {
 273         'dayofweek' : '0'
 274     }
 275 resource_calendar_attendance()
 276
 277 def hours_time_string(hours):
 278     """ convert a number of hours (float) into a string with format '%H:%M' """
 279     minutes = int(round(hours * 60))
 280     return "%02d:%02d" % divmod(minutes, 60)
 281
 282 class resource_resource(osv.osv):
 283     _name = "resource.resource"
 284     _description = "Resource Detail"
 285     _columns = {
 286         'name' : fields.char("Name", size=64, required=True),
 287         'code': fields.char('Code', size=16),
 288         'active' : fields.boolean('Active', help="If the active field is set to False, it will allow you to hide the resource record without removing it."),
 289         'company_id' : fields.many2one('res.company', 'Company'),
 290         'resource_type': fields.selection([('user','Human'),('material','Material')], 'Resource Type', required=True),
 291         'user_id' : fields.many2one('res.users', 'User', help='Related user name for the resource to manage its access.'),
 292         'time_efficiency' : fields.float('Efficiency Factor', size=8, required=True, help="This field depict the efficiency of the resource to complete tasks. e.g  resource put alone on a phase of 5 days with 5 tasks assigned to him, will show a load of 100% for this phase by default, but if we put a efficiency of 200%, then his load will only be 50%."),
 293         'calendar_id' : fields.many2one("resource.calendar", "Working Time", help="Define the schedule of resource"),
 294     }
 295     _defaults = {
 296         'resource_type' : 'user',
 297         'time_efficiency' : 1,
 298         'active' : True,
 299         'company_id': lambda self, cr, uid, context: self.pool.get('res.company')._company_default_get(cr, uid, 'resource.resource', context=context)
 300     }
 301
 302
 303     def copy(self, cr, uid, id, default=None, context=None):
 304         if default is None:
 305             default = {}
 306         if not default.get('name', False):
 307             default.update(name=_('%s (copy)') % (self.browse(cr, uid, id, context=context).name))
 308         return super(resource_resource, self).copy(cr, uid, id, default, context)
 309
 310     def generate_resources(self, cr, uid, user_ids, calendar_id, context=None):
 311         """
 312         Return a list of  Resource Class objects for the resources allocated to the phase.
 313         """
 314         resource_objs = {}
 315         user_pool = self.pool.get('res.users')
 316         for user in user_pool.browse(cr, uid, user_ids, context=context):
 317             resource_objs[user.id] = {
 318                  'name' : user.name,
 319                  'vacation': [],
 320                  'efficiency': 1.0,
 321             }
 322
 323             resource_ids = self.search(cr, uid, [('user_id', '=', user.id)], context=context)
 324             if resource_ids:
 325                 for resource in self.browse(cr, uid, resource_ids, context=context):
 326                     resource_objs[user.id]['efficiency'] = resource.time_efficiency
 327                     resource_cal = resource.calendar_id.id
 328                     if resource_cal:
 329                         leaves = self.compute_vacation(cr, uid, calendar_id, resource.id, resource_cal, context=context)
 330                         resource_objs[user.id]['vacation'] += list(leaves)
 331         return resource_objs
 332
 333     def compute_vacation(self, cr, uid, calendar_id, resource_id=False, resource_calendar=False, context=None):
 334         """
 335         Compute the vacation from the working calendar of the resource.
 336
 337         @param calendar_id : working calendar of the project
 338         @param resource_id : resource working on phase/task
 339         @param resource_calendar : working calendar of the resource
 340         """
 341         resource_calendar_leaves_pool = self.pool.get('resource.calendar.leaves')
 342         leave_list = []
 343         if resource_id:
 344             leave_ids = resource_calendar_leaves_pool.search(cr, uid, ['|', ('calendar_id', '=', calendar_id),
 345                                                                        ('calendar_id', '=', resource_calendar),
 346                                                                        ('resource_id', '=', resource_id)
 347                                                                       ], context=context)
 348         else:
 349             leave_ids = resource_calendar_leaves_pool.search(cr, uid, [('calendar_id', '=', calendar_id),
 350                                                                       ('resource_id', '=', False)
 351                                                                       ], context=context)
 352         leaves = resource_calendar_leaves_pool.read(cr, uid, leave_ids, ['date_from', 'date_to'], context=context)
 353         for i in range(len(leaves)):
 354             dt_start = datetime.strptime(leaves[i]['date_from'], '%Y-%m-%d %H:%M:%S')
 355             dt_end = datetime.strptime(leaves[i]['date_to'], '%Y-%m-%d %H:%M:%S')
 356             no = dt_end - dt_start
 357             [leave_list.append((dt_start + timedelta(days=x)).strftime('%Y-%m-%d')) for x in range(int(no.days + 1))]
 358             leave_list.sort()
 359         return leave_list
 360
 361     def compute_working_calendar(self, cr, uid, calendar_id=False, context=None):
 362         """
 363         Change the format of working calendar from 'Openerp' format to bring it into 'Faces' format.
 364         @param calendar_id : working calendar of the project
 365         """
 366         if not calendar_id:
 367             # Calendar is not specified: working days: 24/7
 368             return [('fri', '8:0-12:0','13:0-17:0'), ('thu', '8:0-12:0','13:0-17:0'), ('wed', '8:0-12:0','13:0-17:0'),
 369                    ('mon', '8:0-12:0','13:0-17:0'), ('tue', '8:0-12:0','13:0-17:0')]
 370         resource_attendance_pool = self.pool.get('resource.calendar.attendance')
 371         time_range = "8:00-8:00"
 372         non_working = ""
 373         week_days = {"0": "mon", "1": "tue", "2": "wed","3": "thu", "4": "fri", "5": "sat", "6": "sun"}
 374         wk_days = {}
 375         wk_time = {}
 376         wktime_list = []
 377         wktime_cal = []
 378         week_ids = resource_attendance_pool.search(cr, uid, [('calendar_id', '=', calendar_id)], context=context)
 379         weeks = resource_attendance_pool.read(cr, uid, week_ids, ['dayofweek', 'hour_from', 'hour_to'], context=context)
 380         # Convert time formats into appropriate format required
 381         # and create a list like [('mon', '8:00-12:00'), ('mon', '13:00-18:00')]
 382         for week in weeks:
 383             res_str = ""
 384             day = None
 385             if week_days.get(week['dayofweek'],False):
 386                 day = week_days[week['dayofweek']]
 387                 wk_days[week['dayofweek']] = week_days[week['dayofweek']]
 388             else:
 389                 raise osv.except_osv(_('Configuration Error!'),_('Make sure the Working time has been configured with proper week days!'))
 390             hour_from_str = hours_time_string(week['hour_from'])
 391             hour_to_str = hours_time_string(week['hour_to'])
 392             res_str = hour_from_str + '-' + hour_to_str
 393             wktime_list.append((day, res_str))
 394         # Convert into format like [('mon', '8:00-12:00', '13:00-18:00')]
 395         for item in wktime_list:
 396             if wk_time.has_key(item[0]):
 397                 wk_time[item[0]].append(item[1])
 398             else:
 399                 wk_time[item[0]] = [item[0]]
 400                 wk_time[item[0]].append(item[1])
 401         for k,v in wk_time.items():
 402             wktime_cal.append(tuple(v))
 403         # Add for the non-working days like: [('sat, sun', '8:00-8:00')]
 404         for k, v in wk_days.items():
 405             if week_days.has_key(k):
 406                 week_days.pop(k)
 407         for v in week_days.itervalues():
 408             non_working += v + ','
 409         if non_working:
 410             wktime_cal.append((non_working[:-1], time_range))
 411         return wktime_cal
 412
 413 resource_resource()
 414
 415 class resource_calendar_leaves(osv.osv):
 416     _name = "resource.calendar.leaves"
 417     _description = "Leave Detail"
 418     _columns = {
 419         'name' : fields.char("Name", size=64),
 420         'company_id' : fields.related('calendar_id','company_id',type='many2one',relation='res.company',string="Company", store=True, readonly=True),
 421         'calendar_id' : fields.many2one("resource.calendar", "Working Time"),
 422         'date_from' : fields.datetime('Start Date', required=True),
 423         'date_to' : fields.datetime('End Date', required=True),
 424         'resource_id' : fields.many2one("resource.resource", "Resource", help="If empty, this is a generic holiday for the company. If a resource is set, the holiday/leave is only for this resource"),
 425     }
 426
 427     def check_dates(self, cr, uid, ids, context=None):
 428          leave = self.read(cr, uid, ids[0], ['date_from', 'date_to'])
 429          if leave['date_from'] and leave['date_to']:
 430              if leave['date_from'] > leave['date_to']:
 431                  return False
 432          return True
 433
 434     _constraints = [
 435         (check_dates, 'Error! leave start-date must be lower then leave end-date.', ['date_from', 'date_to'])
 436     ]
 437
 438     def onchange_resource(self, cr, uid, ids, resource, context=None):
 439         result = {}
 440         if resource:
 441             resource_pool = self.pool.get('resource.resource')
 442             result['calendar_id'] = resource_pool.browse(cr, uid, resource, context=context).calendar_id.id
 443             return {'value': result}
 444         return {'value': {'calendar_id': []}}
 445
 446 resource_calendar_leaves()
 447
 448 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: