diff --git a/addons/project/wizard/compute_tasks_date.py b/addons/project/wizard/compute_tasks_date.py
index 4dbd1c4495b..6d9f87a9ac4 100644
--- a/addons/project/wizard/compute_tasks_date.py
+++ b/addons/project/wizard/compute_tasks_date.py
@@ -44,17 +44,30 @@ compute_fields = {
 def timeformat_convert(cr, uid, time_string, context={}):
 #    Function to convert input time string:: 8.5 to output time string 8:30
 
-        strg = str(time_string)[-2:]
-        last_strg = str(time_string)[0:-2]
-        if strg != '.0':
-            if '.' not in strg:
-                strg = '.' + strg
-                last_strg = str(time_string)[:-3]
-            new_strg = round(float(strg) / 0.016666667)
-            converted_strg = last_strg + ':' + str(new_strg)[:-2]
-        else:
-            converted_strg = last_strg + ':00'
-        return converted_strg
+        split_list = str(time_string).split('.')
+        hour_part = split_list[0]
+        mins_part = split_list[1]
+        round_mins  = int(round(float(mins_part) * 60,-2))
+        converted_string = hour_part + ':' + str(round_mins)[0:2]
+        return converted_string
+
+def leaves_resource(cr,uid,id):
+#    To get the leaves for the members working on project
+
+        pool = pooler.get_pool(cr.dbname)
+        resource_leaves_pool = pool.get('resource.calendar.leaves')
+        resource_leave_ids = resource_leaves_pool.search(cr,uid,[('resource_id','=',id)])
+        leaves = []
+        if resource_leave_ids:
+            res_leaves = resource_leaves_pool.read(cr,uid,resource_leave_ids,['date_from','date_to'])
+            for leave in range(len(res_leaves)):
+                    dt_start = datetime.datetime.strptime(res_leaves[leave]['date_from'],'%Y-%m-%d %H:%M:%S')
+                    dt_end = datetime.datetime.strptime(res_leaves[leave]['date_to'],'%Y-%m-%d %H:%M:%S')
+                    no = dt_end - dt_start
+                    leave_days = no.days + 1
+            [leaves.append((dt_start + datetime.timedelta(days=x)).strftime('%Y-%m-%d')) for x in range(int(leave_days))]
+            leaves.sort()
+        return leaves
 
 class wizard_compute_tasks(wizard.interface):
 
@@ -76,13 +89,14 @@ class wizard_compute_tasks(wizard.interface):
             task_ids.sort()
             task_obj = task_pool.browse(cr,uid,task_ids)
             task_1 = task_obj[0]
-            dt_start = datetime.datetime.strftime(datetime.datetime.strptime(project.date_start,"%Y-%m-%d"),"%Y-%m-%d %H:%M")
+
+            date_start = datetime.datetime.strftime(datetime.datetime.strptime(project.date_start,"%Y-%m-%d"),"%Y-%m-%d %H:%M")
             calendar_id = project.resource_calendar_id.id
 
 #     If project has a working calendar then that would be used otherwise
 #     the default faces calendar would  be used
             if calendar_id:
-                resource_leave_ids = resource_leaves_pool.search(cr,uid,[('calendar_id','=',project.resource_calendar_id.id)])
+                resource_leave_ids = resource_leaves_pool.search(cr,uid,[('calendar_id','=',calendar_id)])
                 time_range = "8:00-8:00"
                 non_working = ""
                 wk = {"0":"mon","1":"tue","2":"wed","3":"thu","4":"fri","5":"sat","6":"sun"}
@@ -99,7 +113,6 @@ class wizard_compute_tasks(wizard.interface):
                     if wk.has_key(week['dayofweek']):
                         day = wk[week['dayofweek']]
                         wk_days[week['dayofweek']] = wk[week['dayofweek']]
-
                     hour_from_str = timeformat_convert(cr,uid,week['hour_from'])
                     hour_to_str = timeformat_convert(cr,uid,week['hour_to'])
                     res_str = hour_from_str + '-' + hour_to_str
@@ -140,8 +153,12 @@ class wizard_compute_tasks(wizard.interface):
             resource = project.members
             resource_objs = []
             for no in range(len(resource)):
+                leaves = []
                 resource_id = resource_pool.search(cr,uid,[('user_id','=',resource[no].id)])
-                resource_objs.append(classobj(str(resource[no].name),(Resource,),{'__doc__':resource[no].name,'__name__':resource[no].name}))
+                if resource_id:
+            #   Getting list of leaves for specific resource
+                    leaves = leaves_resource(cr,uid,resource_id)
+                resource_objs.append(classobj(str(resource[no].name),(Resource,),{'__doc__':resource[no].name,'__name__':resource[no].name,'vacation':tuple(leaves)}))
 
 #     To create dynamic no of tasks
             def tasks(j,eff):
@@ -170,7 +187,7 @@ class wizard_compute_tasks(wizard.interface):
             def Project():
                 resource = reduce(operator.or_,resource_objs)
                 title = project.name
-                start = dt_start
+                start = date_start
 
 #    If project has calendar
                 if wktime_cal or leaves:
@@ -179,7 +196,7 @@ class wizard_compute_tasks(wizard.interface):
 
 #    Dynamic Creation of tasks
                 for i in range(len(task_obj)):
-                    hours = str(task_obj[i].planned_hours / task_obj[i].occupation_rate)[:-2] + 'H'
+                    hours = str(task_obj[i].remaining_hours / task_obj[i].occupation_rate)+ 'H'
                     if task_obj[i].user_id:
                         for resource_object in resource_objs:
                             if resource_object.__name__ == task_obj[i].user_id.name:
@@ -195,7 +212,6 @@ class wizard_compute_tasks(wizard.interface):
                 while loop_no <= task_no:
                     s_date = t.start.to_datetime()
                     e_date = t.end.to_datetime()
-                    print 'Start Date And End Date:::',s_date,e_date,t.name,t.booked_resource
                     if loop_no != 0:
                         user_id = user_pool.search(cr,uid,[('name','=',t.booked_resource[0].__name__)])
                         task_pool.write(cr,uid,[task_obj[loop_no - 1].id],{'date_start':s_date,'date_end':e_date,'user_id':user_id[0]})
diff --git a/addons/project_long_term/project.py b/addons/project_long_term/project.py
index 3f16b33ea31..ffe3ac38842 100644
--- a/addons/project_long_term/project.py
+++ b/addons/project_long_term/project.py
@@ -40,12 +40,12 @@ class project_phase(osv.osv):
          if (obj_self in prev_ids) or (obj_self in next_ids):
              return False
          ids = [id for id in prev_ids if id in next_ids]
-         
+
          #both prev_ids and next_ids must be unique
          if ids:
              return False
          #unrelated project
-         
+
          prev_ids = [rec.id for rec in prev_ids]
          next_ids = [rec.id for rec in next_ids]
 
@@ -59,7 +59,7 @@ class project_phase(osv.osv):
              if ids:
                  return False
              prev_ids = prv_phase_ids
-             
+
         #iter next_ids
          while next_ids:
              cr.execute('select distinct next_phase_id from project_phase_next_rel where phase_id in ('+','.join(map(str, next_ids))+')')
@@ -100,7 +100,9 @@ project_phase()
 class project_resource_allocation(osv.osv):
     _name = 'project.resource.allocation'
     _description = 'Project Resource Allocation'
+    _rec_name = 'resource_id'
     _columns = {
+#        'name': fields.char('Name',size = 64),
         'resource_id': fields.many2one('resource.resource', 'Resource', required=True),
         'phase_id': fields.many2one('project.phase', 'Project Phase', required=True),
         'useability': fields.float('Useability', help="Useability of this ressource for this project phase in percentage (=50%)"),
@@ -108,6 +110,7 @@ class project_resource_allocation(osv.osv):
     _defaults = {
         'useability': lambda *a: 100,
     }
+
 project_resource_allocation()
 
 class project(osv.osv):
diff --git a/addons/project_long_term/wizard/compute_phases_date.py b/addons/project_long_term/wizard/compute_phases_date.py
index 8b3c76c9ef3..f713942708b 100644
--- a/addons/project_long_term/wizard/compute_phases_date.py
+++ b/addons/project_long_term/wizard/compute_phases_date.py
@@ -24,151 +24,204 @@ import pooler
 from tools.translate import _
 import datetime
 from resource.faces import *
+from new import classobj
+import operator
 
 compute_form = """<?xml version="1.0" ?>
-<form string="Compute Scheduling of Tasks">
+<form string="Compute Scheduling of Phases">
 
-    <field name="project_id" colspan="4"/>
+    <field name="phase_id" colspan="4"/>
 
 </form>"""
 
 compute_fields = {
-    'project_id': {'string':'Project', 'type':'many2one', 'relation': 'project.project', 'required':'True'},
+    'phase_id': {'string':'Phase', 'type':'many2one', 'relation': 'project.phase', 'required':'True'},
 
 }
+
+success_msg = """<?xml version="1.0" ?>
+<form string="Compute Scheduling of Phases">
+    <label string="Phase Scheduling completed successfully."/>
+</form>"""
+
 def timeformat_convert(cr, uid, time_string, context={}):
-        strg = str(time_string)[-2:]
-        last_strg = str(time_string)[0:-2]
-        if strg != '.0':
-            if '.' not in strg:
-                strg = '.' + strg
-                last_strg = str(time_string)[:-3]
+#    Function to convert input time string:: 8.5 to output time string 8:30
 
-            new_strg = round(float(strg) / 0.016666667)
-            converted_strg = last_strg + ':' + str(new_strg)[:-2]
-        else:
-            converted_strg = last_strg + ':00'
+        split_list = str(time_string).split('.')
+        hour_part = split_list[0]
+        mins_part = split_list[1]
+        round_mins  = int(round(float(mins_part) * 60,-2))
+        converted_string = hour_part + ':' + str(round_mins)[0:2]
+        return converted_string
 
-        return converted_strg
+def leaves_resource(cr,uid,id):
+#    To get the leaves for the resource_ids working on phase
+
+        pool = pooler.get_pool(cr.dbname)
+        resource_leaves_pool = pool.get('resource.calendar.leaves')
+        resource_leave_ids = resource_leaves_pool.search(cr,uid,[('resource_id','=',id)])
+        leaves = []
+        if resource_leave_ids:
+            res_leaves = resource_leaves_pool.read(cr,uid,resource_leave_ids,['date_from','date_to'])
+            for leave in range(len(res_leaves)):
+                    dt_start = datetime.datetime.strptime(res_leaves[leave]['date_from'],'%Y-%m-%d %H:%M:%S')
+                    dt_end = datetime.datetime.strptime(res_leaves[leave]['date_to'],'%Y-%m-%d %H:%M:%S')
+                    no = dt_end - dt_start
+                    leave_days = no.days + 1
+            [leaves.append((dt_start + datetime.timedelta(days=x)).strftime('%Y-%m-%d')) for x in range(int(leave_days))]
+            leaves.sort()
+        return leaves
+
+def resource_list(cr,uid,obj):
+#    To get the resource_ids working on phase
+
+        pool = pooler.get_pool(cr.dbname)
+        resource_pool = pool.get('resource.resource')
+        resources = obj.resource_ids
+        resource_objs = []
+        for no in range(len(resources)):
+            resource_id = resource_pool.search(cr,uid,[('id','=',resources[no].resource_id.id)])
+            if resource_id:
+            #   Getting list of leaves for specific resource
+                leaves = leaves_resource(cr,uid,resource_id)
+            #   Creating the faces.Resource object with resource specific efficiency and vacation
+                resource_objs.append(classobj(str(resources[no].resource_id.name),(Resource,),{'__doc__':resources[no].resource_id.name,'__name__':resources[no].resource_id.name,'efficiency':resources[no].useability/100,'vacation':tuple(leaves)}))
+        return resource_objs
 
 class wizard_compute_phases(wizard.interface):
 
     def _compute_date(self, cr, uid, data, context):
-        project_id = data['form']['project_id']
-        project = pooler.get_pool(cr.dbname).get('project.project').browse(cr,uid,project_id)
-        phase_ids = pooler.get_pool(cr.dbname).get('project.phase').search(cr,uid,[('project_id','=',project_id)])
-        if phase_ids:
-            phase_obj = pooler.get_pool(cr.dbname).get('project.phase').browse(cr,uid,phase_ids)
-            phase_1 = phase_obj[0]
-            if phase_1.date_start:
-                date_dt = datetime.datetime.strptime(phase_1.date_start,"%Y-%m-%d %H:%M:%S")
-            else:
-                date_dt = datetime.datetime.strptime(project.date_start,"%Y-%m-%d")
-            dt = datetime.datetime.strftime(date_dt,"%Y-%m-%d %H:%M")
+        pool = pooler.get_pool(cr.dbname)
+        project_pool = pool.get('project.project')
+        phase_pool = pool.get('project.phase')
+        resource_pool = pool.get('resource.resource')
+        resource_leaves_pool = pool.get('resource.calendar.leaves')
+        resource_week_pool = pool.get('resource.calendar.week')
+        avg_hr = 0.0
+        wktime_cal = []
+        leaves = []
+        phase_id = data['form']['phase_id']
+        phase = phase_pool.browse(cr,uid,phase_id)
+        calendar_id = phase.project_id.resource_calendar_id.id
 
-            for i in range(len(phase_obj)):
-                final_lst = []
-                leaves = []
-#                if phase_obj[i].user_id.id:
-#                    resource_id = pooler.get_pool(cr.dbname).get('resource.resource').search(cr,uid,[('user_id','=',task_obj[i].user_id.id)])
-#                    resource_obj = pooler.get_pool(cr.dbname).get('resource.resource').browse(cr,uid,resource_id)[0]
-                if project.resource_calendar_id:
-                        non_working = ""
-                        time_range = "8:00-8:00"
-                        wk = {"0":"mon","1":"tue","2":"wed","3":"thu","4":"fri"}
-                        wk_days = {}
-                        wk_time = {}
-                        tlist = []
-                        hours = []
-                        hr = 0
+#     If project has a working calendar then that would be used otherwise
+#     the default faces calendar would  be used
+        if calendar_id:
+            time_range = "8:00-8:00"
+            non_working = ""
+            wk = {"0":"mon","1":"tue","2":"wed","3":"thu","4":"fri","5":"sat","6":"sun"}
+            wk_days = {}
+            wk_time = {}
+            wktime_list = []
+            hours = []
+            hr = 0
+            week_ids = resource_week_pool.search(cr,uid,[('calendar_id','=',calendar_id)])
+            week_obj = resource_week_pool.read(cr,uid,week_ids,['dayofweek','hour_from','hour_to'])
 
-                        week_ids = pooler.get_pool(cr.dbname).get('resource.calendar.week').search(cr,uid,[('calendar_id','=',project.resource_calendar_id.id)])
-                        week_obj = pooler.get_pool(cr.dbname).get('resource.calendar.week').read(cr,uid,week_ids,['dayofweek','hour_from','hour_to'])
+#     Converting time formats into appropriate format required
+#     and creating a list like [('mon', '8:00-12:00'), ('mon', '13:00-18:00')]
+            for week in week_obj:
+                res_str = ""
+                if wk.has_key(week['dayofweek']):
+                    day = wk[week['dayofweek']]
+                    wk_days[week['dayofweek']] = wk[week['dayofweek']]
 
-                        for week in week_obj:
-                            res_str = ""
-                            if wk.has_key(week['dayofweek']):
-                                day = wk[week['dayofweek']]
-                                wk_days[week['dayofweek']] = wk[week['dayofweek']]
+                hour_from_str = timeformat_convert(cr,uid,week['hour_from'])
+                hour_to_str = timeformat_convert(cr,uid,week['hour_to'])
+                res_str = hour_from_str + '-' + hour_to_str
+                hours.append(week['hour_from'])
+                hours.append(week['hour_to'])
+                wktime_list.append((day,res_str))
 
-                            hour_from_str = timeformat_convert(cr,uid,week['hour_from'])
-                            hour_to_str = timeformat_convert(cr,uid,week['hour_to'])
-                            hours.append(week['hour_from'])
-                            hours.append(week['hour_to'])
-                            res_str = hour_from_str + '-' + hour_to_str
-                            tlist.append((day,res_str))
-
-                        for item in tlist:
-                            if wk_time.has_key(item[0]):
-                                wk_time[item[0]].append(item[1])
-                            else:
-                                wk_time[item[0]] = [item[0]]
-                                wk_time[item[0]].append(item[1])
-
-                        for k,v in wk_time.items():
-                            final_lst.append(tuple(v))
-
-                        for k,v in wk_days.items():
-                            if wk.has_key(k):
-                                wk.pop(k)
-                        for v in wk.itervalues():
-                            non_working += v + ','
-                        if non_working:
-                            final_lst.append((non_working[:-1],time_range))
-
-                        leave_ids = pooler.get_pool(cr.dbname).get('resource.calendar.leaves').search(cr,uid,[('calendar_id','=',project.resource_calendar_id.id)])
-                        if leave_ids:
-                            res_leaves = pooler.get_pool(cr.dbname).get('resource.calendar.leaves').read(cr,uid,leave_ids,['date_from','date_to'])
-                            for leave in range(len(res_leaves)):
-                                dt_start = datetime.datetime.strptime(res_leaves[leave]['date_from'],'%Y-%m-%d %H:%M:%S')
-                                dt_end = datetime.datetime.strptime(res_leaves[leave]['date_to'],'%Y-%m-%d %H:%M:%S')
-                                no = dt_end - dt_start
-                                leave_days = no.days + 1
-                            [leaves.append((dt_start + datetime.timedelta(days=x)).strftime('%Y-%m-%d')) for x in range(int(leave_days))]
-                            leaves.sort()
-
-                        for hour in range(0,4):
-                            if hour%2 ==0:
-                                hr += float(hours[hour+1]) - float(hours[hour])
-
-                man_days = str(phase_obj[i].duration * hr)[:-2] + 'H'
-
-                if i == 0:
-                    new_dt = dt
+#     Converting it to format like [('mon', '8:00-12:00', '13:00-18:00')]
+            for item in wktime_list:
+                if wk_time.has_key(item[0]):
+                    wk_time[item[0]].append(item[1])
                 else:
-                    data = pooler.get_pool(cr.dbname).get('project.phase').read(cr,uid,[phase_obj[i-1].id],['date_end'])[0]
-                    if phase_obj[i].constraint_date_start and data['date_end'] < phase_obj[i].constraint_date_start:
-                        new_dt = phase_obj[i].constraint_date_start[0:16]
-                    else:
-                        new_dt = data['date_end'][0:16]
+                    wk_time[item[0]] = [item[0]]
+                    wk_time[item[0]].append(item[1])
 
-                class user(Resource):
-                 pass
+            for k,v in wk_time.items():
+                wktime_cal.append(tuple(v))
 
-                def Project_1():
-                    resource = user
-                    title = project.name
-                    start = new_dt
-                    effort = man_days
+            for hour in range(len(hours)):
+                if hour%2 ==0:
+                    hr += float(hours[hour+1]) - float(hours[hour])
+            avg_hr = hr/len(wktime_cal)
 
-                    if final_lst or leaves:
-                        working_days = final_lst
+#     For non working days adding [('tue,wed,fri,sat,sun', '8:00-8:00')]
+            for k,v in wk_days.items():
+                if wk.has_key(k):
+                    wk.pop(k)
+            for v in wk.itervalues():
+                non_working += v + ','
+            if non_working:
+                wktime_cal.append((non_working[:-1],time_range))
+
+#     If project working calendar has any leaves
+            resource_leave_ids = resource_leaves_pool.search(cr,uid,[('calendar_id','=',calendar_id)])
+            if resource_leave_ids:
+                res_leaves = resource_leaves_pool.read(cr,uid,resource_leave_ids,['date_from','date_to'])
+                for leave in range(len(res_leaves)):
+                    dt_start = datetime.datetime.strptime(res_leaves[leave]['date_from'],'%Y-%m-%d %H:%M:%S')
+                    dt_end = datetime.datetime.strptime(res_leaves[leave]['date_to'],'%Y-%m-%d %H:%M:%S')
+                    no = dt_end - dt_start
+                    leave_days = no.days + 1
+                [leaves.append((dt_start + datetime.timedelta(days=x)).strftime('%Y-%m-%d')) for x in range(int(leave_days))]
+                leaves.sort()
+
+
+        def phase_schedule(cr,uid,phase,start_date,avg_hour = 0.0):
+           if phase:
+
+                #    To get resources and the duration for the phase
+                resources_list = resource_list(cr,uid,phase)
+                if not avg_hour:
+                    avg_hour = 8.0
+                man_days = str(phase.duration * avg_hour) + 'H'
+
+                #    Creating a new project for each phase
+                def Project():
+                    start = start_date
+
+                    #    If project has working calendar else the default one would be considered
+                    if wktime_cal or leaves:
+                        working_days = wktime_cal
                         vacation = tuple(leaves)
 
-                    def phase1():
-                        start = new_dt
+                    def phase():
                         effort = man_days
-                        title = phase_obj[i].name
+                        resource = reduce(operator.or_,resources_list)
 
-                project_1 = BalancedProject(Project_1)
-                start_date = project_1.calendar.WorkingDate(project_1.phase1.start).to_datetime()
-                e_date = project_1.calendar.WorkingDate(project_1.phase1.end).to_datetime()
-                if phase_obj[i].constraint_date_end and str(e_date) > phase_obj[i].constraint_date_end:
-                    end_date = phase_obj[i].constraint_date_end
+                project = BalancedProject(Project)
+                print 'Project Phase Start & End:::',project.phase.name,project.phase.booked_resource,project.phase.start.to_datetime(),project.phase.end.to_datetime()
+                s_date = project.phase.start.to_datetime()
+                e_date = project.phase.end.to_datetime()
+
+                #    According to constraints on date start and date end on phase recalculation done
+                if phase.constraint_date_start and str(s_date) < phase.constraint_date_start:
+                    start_date = phase.constraint_date_start
+                else:
+                    start_date = s_date
+                if phase.constraint_date_end and str(e_date) > phase.constraint_date_end:
+                    end_date = phase.constraint_date_end[:-3]
                 else:
                     end_date = e_date
 
-                pooler.get_pool(cr.dbname).get('project.phase').write(cr,uid,[phase_obj[i].id],{'date_start':start_date,'date_end':end_date})
+                #    Writing the dates back
+                phase_pool.write(cr,uid,[phase.id],{'date_start':start_date,'date_end':end_date})
+                date_start = end_date
+
+                #    Recursive calling the next phases till all the phases are scheduled
+                for phase in phase.next_phase_ids:
+                   phase_schedule(cr,uid,phase,date_start)
+
+        #    Phase Scheduling starts from here with the call to phase_schedule method
+        start_dt = datetime.datetime.strftime((datetime.datetime.strptime(phase.project_id.date_start,"%Y-%m-%d")),"%Y-%m-%d %H:%M")
+        if avg_hr:
+            phase_schedule(cr,uid,phase,start_dt,avg_hr)
+        else:
+            phase_schedule(cr,uid,phase,start_dt)
 
         return {}
     states = {
@@ -176,21 +229,16 @@ class wizard_compute_phases(wizard.interface):
             'actions': [],
             'result': {'type':'form', 'arch':compute_form, 'fields':compute_fields, 'state':[
                 ('end', 'Cancel'),
-                ('ok', 'Ok')
+                ('compute', 'Compute')
 
             ]},
         },
-        'ok': {
+        'compute': {
             'actions': [_compute_date],
-            'result': {'type':'state', 'state':'end'},
+            'result': {'type':'form','arch':success_msg,'fields':{}, 'state':[('end', 'Ok')]},
         }
     }
 wizard_compute_phases('wizard.compute.phases')
 
 
 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
-
-
-
-# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
-