updating a duration will not auto update schedule usage

src/blenderbim/blenderbim/bim/module/resource/operator.py

@@ -424,7 +424,6 @@ class CalculateResourceUsage(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.calculate_resource_usage"
     bl_label = "Calculate Resource Usage"
     bl_options = {"REGISTER", "UNDO"}
-    resource: bpy.props.IntProperty()
 
     @classmethod
     def poll(cls, context):
@@ -434,7 +433,8 @@ class CalculateResourceUsage(bpy.types.Operator, tool.Ifc.Operator):
                 task = tool.Resource.get_task_assignments(active_resource)
                 if task and tool.Sequence.has_duration(task):
                     return True
+
         return False
 
     def _execute(self, context):
-        core.calculate_resource_usage(tool.Ifc, tool.Resource, resource=tool.Ifc.get().by_id(self.resource))
+        core.calculate_resource_usage(tool.Ifc, tool.Resource, resource=tool.Ifc.get().by_id(tool.Resource.get_highlighted_resource()))

src/blenderbim/blenderbim/bim/module/resource/prop.py

@@ -84,16 +84,19 @@ def updateResourceUsage(self, context):
     props = context.scene.BIMResourceProperties
     if not props.is_resource_update_enabled:
         return
-
-    if self.schedule_usage == "":
+    if not self.schedule_usage:
         return
     resource = tool.Ifc.get().by_id(self.ifc_definition_id)
-    tool.Resource.run_edit_resource_time(resource, attributes={"ScheduleUsage": self.schedule_usage})
-    tool.Resource.load_resource_properties()
+    if resource.Usage and resource.Usage.ScheduleUsage == self.schedule_usage:
+        return
+    tool.Resource.run_edit_resource_time(resource, attributes={
+        "ScheduleUsage": self.schedule_usage
+    })
     tool.Sequence.load_task_properties()
+    tool.Resource.load_resource_properties()
+    tool.Sequence.refresh_task_resources()
     blenderbim.bim.module.resource.data.refresh()
     blenderbim.bim.module.sequence.data.refresh()
-    tool.Sequence.refresh_task_resources()
     blenderbim.bim.module.pset.data.refresh()
 
 

src/blenderbim/blenderbim/bim/module/resource/ui.py

@@ -142,7 +142,7 @@ class BIM_PT_resources(Panel):
                 row2col2 = col2.row()
                 row2col2.prop(self.tprops.resources[self.props.active_resource_index], "schedule_usage", text="")
                 row2col3 = col3.row()
-                row2col3.operator("bim.calculate_resource_usage", text="", icon="TEMP").resource = ifc_definition_id
+                row2col3.operator("bim.calculate_resource_usage", text="", icon="TEMP")
                 op = row2col3.operator(
                     "bim.add_usage_constraint" if not is_usage_locked else "bim.remove_usage_constraint",
                     text="",

src/blenderbim/blenderbim/bim/module/sequence/prop.py

@@ -225,7 +225,9 @@ def updateTaskDuration(self, context):
         task_time = tool.Ifc.run("sequence.add_task_time", task=task)
     tool.Ifc.run("sequence.edit_task_time", task_time=task_time, attributes={"ScheduleDuration": duration})
     SequenceData.load()
+    blenderbim.core.sequence.load_task_properties(tool.Sequence)
     bpy.ops.bim.load_task_properties()
+    tool.Sequence.load_resources()
 
 
 def get_schedule_predefined_types(self, context):

src/blenderbim/blenderbim/core/resource.py

@@ -23,7 +23,6 @@ def load_resources(resource):
     resource.load_resources()
     resource.load_resource_properties()
 
-
 def add_resource(tool_ifc, resource_tool, ifc_class, parent_resource=None):
     tool_ifc.run("resource.add_resource", ifc_class=ifc_class, parent_resource=parent_resource)
     load_resources(resource_tool)
@@ -184,7 +183,7 @@ def edit_productivity_pset(ifc, resource_tool):
 
 
 def add_usage_constraint(ifc, resource_tool, resource=None, reference_path=None):
-    metric = resource_tool.has_usage_metric(resource)
+    metric = resource_tool.has_metric_constraint(resource, "Usage")
     if metric:
         return print("Must remove existing metric first")
 

src/blenderbim/blenderbim/core/sequence.py

@@ -193,6 +193,7 @@ def edit_task_time(ifc, sequence, task_time=None):
     task = sequence.get_active_task()
     sequence.load_task_properties(task=task)
     sequence.disable_editing_task_time()
+    sequence.load_resources()
 
 
 def assign_predecessor(ifc, sequence, task=None):

src/blenderbim/blenderbim/core/tool.py

@@ -615,8 +615,7 @@ class Resource:
     def get_resource_time_attributes(cls): pass
     def get_resource_time(cls, resource): pass
     def go_to_resource(cls, resource): pass
-    def has_metric_constraint(cls, resource, attribute): pass
-    def has_usage_metric(cls, resource): pass
+    def has_metric_constraint(cls, resource): pass
     def import_resources(cls, file_path): pass
     def load_cost_value_attributes(cls, cost_value): pass
     def load_productivity_data(cls): pass

src/blenderbim/blenderbim/tool/resource.py

@@ -397,12 +397,8 @@ class Resource(blenderbim.core.tool.Resource):
 
     @classmethod
     def has_metric_constraint(cls, resource, attribute):
-        metrics = ifcopenshell.util.constraint.has_metric_constraints(resource, attribute)
-        return metrics[0] if metrics else None
-
-    @classmethod
-    def has_usage_metric(cls, resource):
-        return cls.has_metric_constraint(resource, "Usage")
+        metrics = ifcopenshell.util.constraint.get_metric_constraints(resource, attribute)
+        return True if metrics else False
 
     @classmethod
     def run_edit_resource_time(cls, resource, attributes):
@@ -446,4 +442,8 @@ class Resource(blenderbim.core.tool.Resource):
 
     @classmethod
     def get_nested_resources(cls, resource):
-        return ifcopenshell.util.resource.get_nested_resources(resource)
+        return ifcopenshell.util.resource.get_nested_resources(resource)
+
+    @classmethod
+    def is_attribute_locked(cls, resource, attribute):
+        return ifcopenshell.util.constraint.is_attribute_locked(resource, attribute)

src/blenderbim/blenderbim/tool/sequence.py

@@ -421,6 +421,7 @@ class Sequence(blenderbim.core.tool.Sequence):
     @classmethod
     def load_resources(cls):
         blenderbim.core.resource.load_resources(tool.Resource)
+        cls.refresh_task_resources
 
     @classmethod
     def get_task_inputs(cls, task):