From 82e99ba71744f3dbb6db1042bf3d490df1f627c6 Mon Sep 17 00:00:00 2001
From: jeisenma <Jordan.Eisenman@nrel.gov>
Date: Mon, 16 Sep 2024 18:34:04 -0600
Subject: [PATCH 1/6] initial changes

---
 calliope_app/api/models/configuration.py      |  21 ++-
 calliope_app/client/static/js/main.js         | 135 ++++++++++--------
 .../templates/technology_parameters.html      |  21 ++-
 postgres/.gitkeep                             |   0
 4 files changed, 114 insertions(+), 63 deletions(-)
 delete mode 100644 postgres/.gitkeep

diff --git a/calliope_app/api/models/configuration.py b/calliope_app/api/models/configuration.py
index bfee4a0e..884f7bf2 100644
--- a/calliope_app/api/models/configuration.py
+++ b/calliope_app/api/models/configuration.py
@@ -830,11 +830,30 @@ def duplicate(self, model_id, pretty_name):
 
     def update(self, form_data):
         """ Update the Technology parameters stored in Tech_Param """
+        print("Update Data", form_data)
         METHODS = ['essentials', 'add', 'edit', 'delete']
         for method in METHODS:
             if method in form_data.keys():
                 data = form_data[method]
-                getattr(Tech_Param, '_' + method)(self, data)
+                if method == 'essentials':
+                    self._update_essentials(data)
+                elif method == 'add':
+                    self._add_parameters(data)
+                elif method == 'edit':
+                    if 'parameter_instance' in data:
+                        for param_id, param_data in data['parameter_instance'].items():
+                            tech_param = Tech_Param.objects.get(id=param_id, technology=self)
+                            if 'build_year_offset' in param_data:
+                                tech_param.build_year_offset = param_data['build_year_offset']
+                            if 'year' in param_data:
+                                tech_param.year = param_data['year']
+                            if 'value' in param_data:
+                                tech_param.value = param_data['value']
+                            tech_param.save()
+                    else:
+                        self._edit_parameters(data)
+                elif method == 'delete':
+                    self._delete_parameters(data)
 
 
 class Tech_Param(models.Model):
diff --git a/calliope_app/client/static/js/main.js b/calliope_app/client/static/js/main.js
index 82e27754..c388f96a 100644
--- a/calliope_app/client/static/js/main.js
+++ b/calliope_app/client/static/js/main.js
@@ -13,67 +13,76 @@ $(function() {
 			$(this).slideUp(500);
 		});
 });
-
 function activate_table() {
+    $('.parameter-value.float-value').each(function() {
+        autocomplete_units(this);
+    });
+
+    // Detection of unsaved changes
+    $('.parameter-value-new, .parameter-value-existing, .parameter-year-existing, .parameter-build-year-offset-existing').unbind();
+    $('.parameter-value-new, .parameter-value-existing, .parameter-year-existing, .parameter-build-year-offset-existing').on('focusout', function() {
+        if ($(this).val() == '') { $(this).val( $(this).data('value') ) };
+    });
+    $('.parameter-value-new, .parameter-value-existing, .parameter-year-existing, .parameter-build-year-offset-existing').on('change keyup paste', function() {
+        var row = $(this).parents('tr'),
+            year = row.find('.parameter-year').val(),
+            old_year = row.find('.parameter-year').data('value'),
+            build_year_offset = row.find('.parameter-build-year-offset').val(),
+            old_build_year_offset = row.find('.parameter-build-year-offset').data('value'),
+            value = row.find('.parameter-value').val(),
+            old_value = row.find('.parameter-value').data('value'),
+            param_id = $(this).parents('tr').data('param_id'),
+            ts_id = row.find('.parameter-value.timeseries').val();
+        
+        // Convert to number if possible
+        if (+value) { value = +value };
+        if (+old_value) { old_value = +old_value };
+        if (+build_year_offset) { build_year_offset = +build_year_offset };
+        if (+old_build_year_offset) { old_build_year_offset = +old_build_year_offset };
+        
+        // If it is a timeseries: render the charts
+        if (ts_id) {
+            activate_charts(param_id, ts_id)
+        };
+        
+        // Reset the formatting of row
+        row.find('.parameter-reset').addClass('hide')
+        row.find('.parameter-delete, .parameter-value-delete').removeClass('hide')
+        row.removeClass('table-warning');
+        $(this).removeClass('invalid-value');
+
+        // Update Row based on Input
+        var update_val = (value != '') && (value != old_value),
+            update_year = (year != '') && (year != old_year),
+            update_build_year_offset = (build_year_offset != '') && (build_year_offset != old_build_year_offset);
+        
+        if (update_val && ($(this).hasClass('float-value') == true)) {
+            var units = row.find('.parameter-units').attr('data-value'),
+                val = convert_units(value, units);
+            if (typeof(val) == 'number') {
+                $(this).attr('data-target_value', formatNumber(val, false));
+                row.find('.parameter-target-value').html(formatNumber(val, true));
+                row.find('.parameter-reset').removeClass('hide')
+                row.find('.parameter-delete, .parameter-value-delete').addClass('hide')
+                row.addClass('table-warning');
+            } else {
+                $(this).addClass('invalid-value');
+                row.find('.parameter-target-value').html(row.find('.parameter-target-value').data('value'));
+            }
+        } else if (update_val || update_year || update_build_year_offset) {
+            row.find('.parameter-reset').removeClass('hide')
+            row.find('.parameter-delete, .parameter-value-delete').addClass('hide')
+            row.addClass('table-warning');
+        } else {
+            row.find('.parameter-target-value').html(row.find('.parameter-target-value').data('value'));
+        }
+        check_unsaved();
+    });
 
-	$('.parameter-value.float-value').each(function() {
-		autocomplete_units(this);
-	});
-
-	// Detection of unsaved changes
-	$('.parameter-value-new, .parameter-value-existing, .parameter-year-existing').unbind();
-	$('.parameter-value-new, .parameter-value-existing, .parameter-year-existing').on('focusout', function() {
-		if ($(this).val() == '') { $(this).val( $(this).data('value') ) };
-	});
-	$('.parameter-value-new, .parameter-value-existing, .parameter-year-existing').on('change keyup paste', function() {
-		var row = $(this).parents('tr'),
-			year = row.find('.parameter-year').val(),
-			old_year = row.find('.parameter-year').data('value'),
-			value = row.find('.parameter-value').val(),
-			old_value = row.find('.parameter-value').data('value'),
-			param_id = $(this).parents('tr').data('param_id'),
-			ts_id = row.find('.parameter-value.timeseries').val();
-		// Convert to number if possible
-		if (+value) { value = +value };
-		if (+old_value) { old_value = +old_value };
-		// If it is a timeseries: render the charts
-		if (ts_id) {
-			activate_charts(param_id, ts_id)
-		};
-		// Reset the formatting of row
-		row.find('.parameter-reset').addClass('hide')
-		row.find('.parameter-delete, .parameter-value-delete').removeClass('hide')
-		row.removeClass('table-warning');
-		$(this).removeClass('invalid-value');
-
-		// Update Row based on Input
-		var update_val = (value != '') & (value != old_value),
-			update_year = (year != '') & (year != old_year);
-		if (update_val & ($(this).hasClass('float-value') == true)) {
-			var units = row.find('.parameter-units').attr('data-value'),
-				val = convert_units(value, units);
-			if (typeof(val) == 'number') {
-				$(this).attr('data-target_value', formatNumber(val, false));
-				row.find('.parameter-target-value').html(formatNumber(val, true));
-				row.find('.parameter-reset').removeClass('hide')
-				row.find('.parameter-delete, .parameter-value-delete').addClass('hide')
-				row.addClass('table-warning');
-			} else {
-				$(this).addClass('invalid-value');
-				row.find('.parameter-target-value').html(row.find('.parameter-target-value').data('value'));
-			}
-		} else if (update_val || update_year) {
-			row.find('.parameter-reset').removeClass('hide')
-			row.find('.parameter-delete, .parameter-value-delete').addClass('hide')
-			row.addClass('table-warning');
-		} else {
-			row.find('.parameter-target-value').html(row.find('.parameter-target-value').data('value'));
-		}
-		check_unsaved();
-	});
 	// Paste multiple values
-	activate_paste('.dynamic_value_input');
-	activate_paste('.dynamic_year_input');
+    activate_paste('.dynamic_value_input');
+    activate_paste('.dynamic_year_input');
+    activate_paste('.dynamic_build_year_offset_input');
 
 	// Reset parameter to saved value in database
 	$('.parameter-reset').unbind();
@@ -168,9 +177,10 @@ function activate_table() {
 	});
 
 	// Allow 'return' key to tab through input cells
-	activate_return('.static_inputs');
-	activate_return('.dynamic_year_input');
-	activate_return('.dynamic_value_input');
+    activate_return('.static_inputs');
+    activate_return('.dynamic_year_input');
+    activate_return('.dynamic_build_year_offset_input');
+    activate_return('.dynamic_value_input');
 
 	// Show and Hide the parameter rows
 	$('.param_row_toggle').unbind();
@@ -1143,6 +1153,7 @@ function reconvert_all(load_flg){
 }
 
 function activate_paste(class_name) {
+	console.log(class_name);
 	$(class_name).bind('paste', null, function(e) {
 		var values = e.originalEvent.clipboardData.getData('Text').split(/\s+/),
 			$txt = $(this),
@@ -1206,6 +1217,8 @@ function add_row($this) {
 	row.find('.param_row_toggle').find('.view_rows').addClass('hide');
 	var add_row = $('.add_param_row_'+param_id).last().clone();
 	add_row.find('.parameter-value-new').addClass('dynamic_value_input');
+	add_row.find('.parameter-build-year-offset-new').addClass('dynamic_build_year_offset_input');
+
 	add_row.find('.parameter-year-new').addClass('dynamic_year_input');
 	add_row.removeClass('add_param_row_min').addClass('table-warning');
 	add_row.insertBefore($('.add_param_row_'+param_id).last());
diff --git a/calliope_app/client/templates/technology_parameters.html b/calliope_app/client/templates/technology_parameters.html
index 26fd6b59..526a59b5 100644
--- a/calliope_app/client/templates/technology_parameters.html
+++ b/calliope_app/client/templates/technology_parameters.html
@@ -140,6 +140,7 @@
 					<td class="centered"><i class="fa fa-info-circle"></i></td>
 					<td colspan=2>{% trans "This parameter is configured to evolve over multiple years" %}.</td>
 					<td><b>{% trans "Year" %}:</b></td>
+					<td><b>{% trans "Build Offset Year" %}:</b></td>
 					<td><b>{% trans "Value" %}:</b></td>
 					<td colspan=3></td>
 				</tr>
@@ -161,7 +162,19 @@
 					<td class="">
 						<input {% if not can_edit %}disabled{% endif %} type="number" class="dynamic_year_input form-control parameter-year parameter-year-existing" value="{{ param.year }}" data-value="{{ param.year }}" {% if param.level == level %}name="edit[parameter_instance][{{ param.id }}][year]"{% else %}name="add[{{ param.parameter_id }}][year][]"{% endif %}>
 					</td>
-					<!-- Value -->
+					<td class="">
+						<input {% if not can_edit %}disabled{% endif %} 
+							   type="number" 
+							   class="dynamic_build_year_offset_input form-control parameter-build-year-offset parameter-build-year-offset-existing" 
+							   value="{{ param.build_year_offset }}" 
+							   data-value="{{ param.build_year_offset }}" 
+							   {% if param.level == level %}
+								   name="edit[parameter_instance][{{ param.id }}][build_year_offset]"
+							   {% else %}
+								   name="add[{{ param.parameter_id }}][build_year_offset][]"
+							   {% endif %}>
+					</td>
+															<!-- Value -->
 					<td class="centered">
 						{% if param.choices or param.parameter_is_carrier %}
 						<select {% if not can_edit %}disabled{% endif %} class="dynamic_value_input form-control parameter-value parameter-value-existing" {% if param.level == level %}name="edit[parameter_instance][{{ param.id }}][value]"{% else %}name="add[{{ param.parameter_id }}][value][]"{% endif %} data-value="{{ param.value }}">
@@ -208,6 +221,12 @@
 					<td class="centered">
 						<input {% if not can_edit %}disabled{% endif %} type="number" class="form-control parameter-year parameter-year-new" placeholder="YYYY" name="add[{{ param.parameter_id }}][year][]">
 					</td>
+					<td class="centered">
+						<input {% if not can_edit %}disabled{% endif %} 
+							   type="number" 
+							   class="form-control parameter-build-year-offset parameter-build-year-offset-new" 
+							   name="add[{{ param.parameter_id }}][build_year_offset][]">
+					</td>
 					<td class="centered">
 						{% if param.choices or param.parameter_is_carrier %}
 						<select {% if not can_edit %}disabled{% endif %} class="form-control parameter-value parameter-value-new" name="add[{{ param.parameter_id }}][value][]">
diff --git a/postgres/.gitkeep b/postgres/.gitkeep
deleted file mode 100644
index e69de29b..00000000

From b607e0b55caf850da7bef7cac627452cb45ba1aa Mon Sep 17 00:00:00 2001
From: jeisenma <Jordan.Eisenman@nrel.gov>
Date: Tue, 17 Sep 2024 12:06:17 -0600
Subject: [PATCH 2/6] pushing for almost final changes

---
 calliope_app/api/models/configuration.py      | 203 +++++++-----------
 .../client/component_views/configuration.py   |  13 +-
 calliope_app/client/static/js/main.js         |  23 +-
 .../templates/technology_parameters.html      |  12 +-
 4 files changed, 109 insertions(+), 142 deletions(-)

diff --git a/calliope_app/api/models/configuration.py b/calliope_app/api/models/configuration.py
index 884f7bf2..b306a3bc 100644
--- a/calliope_app/api/models/configuration.py
+++ b/calliope_app/api/models/configuration.py
@@ -827,33 +827,15 @@ def duplicate(self, model_id, pretty_name):
             tech_param.save()
         new_tech.update_calliope_pretty_name()
         return new_tech
+    
 
     def update(self, form_data):
         """ Update the Technology parameters stored in Tech_Param """
-        print("Update Data", form_data)
         METHODS = ['essentials', 'add', 'edit', 'delete']
         for method in METHODS:
             if method in form_data.keys():
                 data = form_data[method]
-                if method == 'essentials':
-                    self._update_essentials(data)
-                elif method == 'add':
-                    self._add_parameters(data)
-                elif method == 'edit':
-                    if 'parameter_instance' in data:
-                        for param_id, param_data in data['parameter_instance'].items():
-                            tech_param = Tech_Param.objects.get(id=param_id, technology=self)
-                            if 'build_year_offset' in param_data:
-                                tech_param.build_year_offset = param_data['build_year_offset']
-                            if 'year' in param_data:
-                                tech_param.year = param_data['year']
-                            if 'value' in param_data:
-                                tech_param.value = param_data['value']
-                            tech_param.save()
-                    else:
-                        self._edit_parameters(data)
-                elif method == 'delete':
-                    self._delete_parameters(data)
+                getattr(Tech_Param, '_' + method)(self, data)
 
 
 class Tech_Param(models.Model):
@@ -953,10 +935,11 @@ def _cplus_carriers(cls, technology, carriers, ratios):
     def _add(cls, technology, data):
         """ Add a new parameter to a technology """
         for key, value_dict in data.items():
-            if (('year' in value_dict) & ('value' in value_dict)):
+            if all(field in value_dict for field in ['year', 'value', 'build_year_offset']):
                 years = value_dict['year']
                 values = value_dict['value']
-                num_records = np.min([len(years), len(values)])
+                build_year_offsets = value_dict['build_year_offset']
+                num_records = min(len(years), len(values), len(build_year_offsets))
                 new_objects = []
                 for i in range(num_records):
                     vals = str(values[i]).split('||')
@@ -964,54 +947,33 @@ def _add(cls, technology, data):
                         model_id=technology.model_id,
                         technology_id=technology.id,
                         year=years[i],
+                        build_year_offset=build_year_offsets[i],
                         parameter_id=key,
                         value=ParamsManager.clean_str_val(vals[0]),
-                        raw_value=vals[1] if len(vals) > 1 else vals[0]))
+                        raw_value=vals[1] if len(vals) > 1 else vals[0]
+                    ))
                 cls.objects.bulk_create(new_objects)
-
     @classmethod
     def _edit(cls, technology, data):
-        """ Edit a technology's parameters """
-        if 'parameter' in data:
-            for key, value in data['parameter'].items():
-                vals = str(value).split('||')
-                cls.objects.filter(
-                    model_id=technology.model_id,
-                    technology_id=technology.id,
-                    parameter_id=key).hard_delete()
-                cls.objects.create(
-                    model_id=technology.model_id,
-                    technology_id=technology.id,
-                    parameter_id=key,
-                    value=ParamsManager.clean_str_val(vals[0]),
-                    raw_value=vals[1] if len(vals) > 1 else vals[0])
-        if 'timeseries' in data:
-            for key, value in data['timeseries'].items():
-                cls.objects.filter(
-                    model_id=technology.model_id,
-                    technology_id=technology.id,
-                    parameter_id=key).hard_delete()
-                cls.objects.create(
-                    model_id=technology.model_id,
-                    technology_id=technology.id,
-                    parameter_id=key,
-                    value=ParamsManager.clean_str_val(value),
-                    timeseries_meta_id=value,
-                    timeseries=True)
         if 'parameter_instance' in data:
-            instance_items = data['parameter_instance'].items()
-            for key, value_dict in instance_items:
-                parameter_instance = cls.objects.filter(
-                    model_id=technology.model_id,
-                    id=key)
-                if 'value' in value_dict:
-                    vals = str(value_dict['value']).split('||')
-                    parameter_instance.update(
-                        value=ParamsManager.clean_str_val(vals[0]),
-                        raw_value=vals[1] if len(vals) > 1 else vals[0])
-                if 'year' in value_dict:
-                    parameter_instance.update(year=value_dict['year'])
-
+            for param_id, param_data in data['parameter_instance'].items():
+                tech_param = cls.objects.filter(id=param_id, technology=technology).first()
+                if tech_param:
+                    if 'build_year_offset' in param_data:
+                        tech_param.build_year_offset = param_data['build_year_offset']
+                    if 'year' in param_data:
+                        tech_param.year = param_data['year']
+                    if 'value' in param_data:
+                        value = param_data['value']
+                        if '||' in value:
+                            parts = value.split('||')
+                            tech_param.value = parts[0].strip()
+                            tech_param.raw_value = parts[1].strip() if len(parts) > 1 else parts[0].strip()
+                        else:
+                            tech_param.value = value
+                            tech_param.raw_value = value
+                    tech_param.save()
+    
     @classmethod
     def _delete(cls, technology, data):
         """ Delete a technology's parameters """
@@ -1028,7 +990,6 @@ def _delete(cls, technology, data):
                     model_id=technology.model_id,
                     id=key).hard_delete()
 
-
 class Location(models.Model):
     class Meta:
         db_table = "location"
@@ -1087,7 +1048,6 @@ def __str__(self):
         else:
             return '%s | %s [%s]' % (self.location_1, self.technology,
                                      self.technology.pretty_tag)
-
     def update(self, form_data):
         """ Update the Location Technology parameters
         stored in Loc_Tech_Param """
@@ -1128,80 +1088,71 @@ class Meta:
     def _add(cls, loc_tech, data):
         """ Add a new parameter to a location technology """
         for key, value_dict in data.items():
-            if (('year' in value_dict) & ('value' in value_dict)):
+            if all(field in value_dict for field in ['year', 'value', 'build_year_offset']):
                 years = value_dict['year']
                 values = value_dict['value']
-                num_records = np.min([len(years), len(values)])
+                build_year_offsets = value_dict['build_year_offset']
+                num_records = min(len(years), len(values), len(build_year_offsets))
                 new_objects = []
                 for i in range(num_records):
-                    vals = str(values[i]).split('||')
+                    value = str(values[i])
+                    if '||' in value:
+                        clean_value, raw_value = value.split('||')
+                    else:
+                        clean_value = raw_value = value
+                    
                     new_objects.append(cls(
-                        model_id=loc_tech.model_id,
-                        loc_tech_id=loc_tech.id,
+                        model_id=loc_tech.model.id,
+                        loc_tech=loc_tech,
                         year=years[i],
+                        build_year_offset=build_year_offsets[i],
                         parameter_id=key,
-                        value=ParamsManager.clean_str_val(vals[0]),
-                        raw_value=vals[1] if len(vals) > 1 else vals[0]))
+                        value=ParamsManager.clean_str_val(clean_value.strip()),
+                        raw_value=raw_value.strip()
+                    ))
                 cls.objects.bulk_create(new_objects)
-
     @classmethod
     def _edit(cls, loc_tech, data):
-        """ Edit a location technology parameter """
-        if 'parameter' in data:
+        if 'parameter_instance' in data:
+            for param_id, param_data in data['parameter_instance'].items():
+                loc_tech_param = cls.objects.filter(id=param_id, loc_tech=loc_tech).first()
+                if loc_tech_param:
+                    if 'build_year_offset' in param_data:
+                        build_year_offset = param_data['build_year_offset']
+                        loc_tech_param.build_year_offset = int(build_year_offset) if build_year_offset != '' else None
+                    if 'year' in param_data:
+                        loc_tech_param.year = param_data['year']
+                    if 'value' in param_data:
+                        value = param_data['value']
+                        if '||' in value:
+                            clean_value, raw_value = value.split('||')
+                        else:
+                            clean_value = raw_value = value
+                        loc_tech_param.value = ParamsManager.clean_str_val(clean_value.strip())
+                        loc_tech_param.raw_value = raw_value.strip()
+                    loc_tech_param.save()
+        elif 'parameter' in data:
             for key, value in data['parameter'].items():
-                vals = str(value).split('||')
-                cls.objects.filter(
-                    model_id=loc_tech.model_id,
-                    loc_tech_id=loc_tech.id,
-                    parameter_id=key).hard_delete()
-                cls.objects.create(
-                    model_id=loc_tech.model_id,
-                    loc_tech_id=loc_tech.id,
-                    parameter_id=key,
-                    value=ParamsManager.clean_str_val(vals[0]),
-                    raw_value=vals[1] if len(vals) > 1 else vals[0])
-        if 'timeseries' in data:
-            for key, value in data['timeseries'].items():
-                cls.objects.filter(
-                    model_id=loc_tech.model_id,
-                    loc_tech_id=loc_tech.id,
-                    parameter_id=key).hard_delete()
-                cls.objects.create(
-                    model_id=loc_tech.model_id,
-                    loc_tech_id=loc_tech.id,
+                if '||' in value:
+                    clean_value, raw_value = value.split('||')
+                else:
+                    clean_value = raw_value = value
+                cls.objects.update_or_create(
+                    loc_tech=loc_tech,
                     parameter_id=key,
-                    value=ParamsManager.clean_str_val(value),
-                    timeseries_meta_id=value,
-                    timeseries=True)
-        if 'parameter_instance' in data:
-            instance_items = data['parameter_instance'].items()
-            for key, value_dict in instance_items:
-                parameter_instance = cls.objects.filter(
-                    model_id=loc_tech.model_id,
-                    id=key)
-                if 'value' in value_dict:
-                    vals = str(value_dict['value']).split('||')
-                    parameter_instance.update(
-                        value=ParamsManager.clean_str_val(vals[0]),
-                        raw_value=vals[1] if len(vals) > 1 else vals[0])
-                if 'year' in value_dict:
-                    parameter_instance.update(year=value_dict['year'])
-
+                    defaults={
+                        'value': ParamsManager.clean_str_val(clean_value.strip()),
+                        'raw_value': raw_value.strip(),
+                        'model': loc_tech.model
+                    }
+                )
     @classmethod
     def _delete(cls, loc_tech, data):
-        """ Delete a location technology parameter """
-        if 'parameter' in data:
-            for key, value in data['parameter'].items():
-                cls.objects.filter(
-                    model_id=loc_tech.model_id,
-                    loc_tech_id=loc_tech.id,
-                    parameter_id=key).hard_delete()
-        elif 'parameter_instance' in data:
-            instance_items = data['parameter_instance'].items()
-            for key, value in instance_items:
-                cls.objects.filter(
-                    model_id=loc_tech.model_id,
-                    id=key).hard_delete()
+        param_ids = data.get('parameter_instance', [])
+        for param_id in param_ids:
+            print(f"Deleting Loc_Tech_Param with id: {param_id}")
+            cls.objects.filter(id=param_id, loc_tech=loc_tech).delete()
+
 
 
 class Scenario(models.Model):
diff --git a/calliope_app/client/component_views/configuration.py b/calliope_app/client/component_views/configuration.py
index 4057b59f..06de33ab 100644
--- a/calliope_app/client/component_views/configuration.py
+++ b/calliope_app/client/component_views/configuration.py
@@ -13,7 +13,7 @@
 from django.utils.timezone import make_aware
 
 from api.models.configuration import Scenario_Param, Scenario, Scenario_Loc_Tech, \
-    Timeseries_Meta, ParamsManager, Model, User_File, Carrier, Tech_Param
+    Timeseries_Meta, ParamsManager, Model, User_File, Carrier, Tech_Param, Loc_Tech_Param
 from api.utils import get_cols_from_csv
 
 
@@ -158,7 +158,9 @@ def all_tech_params(request):
 
     for param in parameters:
         param['raw_units'] = param['units']
-
+        tech_param = Loc_Tech_Param.objects.filter(id=param['id']).first()
+        build_year_offset = tech_param.build_year_offset if tech_param else None
+        param['build_year_offset'] = build_year_offset
     timeseries = Timeseries_Meta.objects.filter(model=model, failure=False,
                                                 is_uploading=False)
 
@@ -273,7 +275,6 @@ def all_loc_tech_params(request):
     parameters = ParamsManager.all_loc_tech_params(loc_tech)
     timeseries = Timeseries_Meta.objects.filter(model=model, failure=False,
                                                 is_uploading=False)
-
     units_in_ids= ParamsManager.get_tagged_params('units_in')
     units_out_ids= ParamsManager.get_tagged_params('units_out')
 
@@ -294,9 +295,13 @@ def all_loc_tech_params(request):
 
     for param in parameters:
         param['raw_units'] = param['units']
-
+        loc_tech_param = Loc_Tech_Param.objects.filter(id=param['id']).first()
+        build_year_offset = loc_tech_param.build_year_offset if loc_tech_param else None
+        param['build_year_offset'] = build_year_offset
+    print(parameters)
     emissions = ParamsManager.emission_categories()
     # Parameters Table
+    print(loc_tech)
     context = {
         "emissions": emissions,
         "loc_tech": loc_tech,
diff --git a/calliope_app/client/static/js/main.js b/calliope_app/client/static/js/main.js
index c388f96a..27050e75 100644
--- a/calliope_app/client/static/js/main.js
+++ b/calliope_app/client/static/js/main.js
@@ -47,7 +47,12 @@ function activate_table() {
         
         // Reset the formatting of row
         row.find('.parameter-reset').addClass('hide')
-        row.find('.parameter-delete, .parameter-value-delete').removeClass('hide')
+        $('.parameter-delete').on('click', function() {
+			var row = $(this).parents('tr');
+			// Deletion logic here
+		});
+		
+		
         row.removeClass('table-warning');
         $(this).removeClass('invalid-value');
 
@@ -113,21 +118,27 @@ function activate_table() {
 	$('.parameter-delete').on('click', function() {
 		var row = $(this).parents('tr'),
 			param_id = row.data('param_id'),
-			rows = $('tr[data-param_id='+param_id+']');
+			rows = $('tr[data-param_id=' + param_id + ']');
+		
 		if (row.hasClass('table-danger')) {
-			rows.find('.check_delete').prop("checked", false)
+			// Unmark for deletion
+			rows.find('.check_delete').prop("checked", false);
 			rows.removeClass('table-danger');
+			rows.addClass('table-warning');  // Add warning class to indicate unsaved change
 			rows.find('.parameter-value, .parameter-year').prop('disabled', false);
 			change_timeseries_color(param_id, true);
 		} else {
-			rows.find('.check_delete').prop("checked", true)
+			// Mark for deletion
+			rows.find('.check_delete').prop("checked", true);
 			rows.addClass('table-danger');
-			rows.find('.parameter-value, .parameter-year').prop('disabled', true)
+			rows.addClass('table-warning');  // Add warning class to indicate unsaved change
+			rows.find('.parameter-value, .parameter-year').prop('disabled', true);
 			change_timeseries_color(param_id, false);
 		}
+		
 		check_unsaved();
 	});
-	$('.parameter-value-delete').unbind();
+		$('.parameter-value-delete').unbind();
 	$('.parameter-value-delete').on('click', function() {
 		var row = $(this).parents('tr');
 		if (row.hasClass('table-danger')) {
diff --git a/calliope_app/client/templates/technology_parameters.html b/calliope_app/client/templates/technology_parameters.html
index 526a59b5..471f07f4 100644
--- a/calliope_app/client/templates/technology_parameters.html
+++ b/calliope_app/client/templates/technology_parameters.html
@@ -159,6 +159,7 @@
 				<tr class="param_row param_row_min param_row_{{ param.parameter_id }} {% if param.level == level %}{% if param.parameter_category == 'Costs: Monetary' %}table-success{% elif param.parameter_category in emissions %}table-info{% else %}table-primary{% endif %}{% else %}table-default{% endif %}" data-param_id={{ param.parameter_id }}>
 					<td colspan=3 style="background-color: white;"></td>
 					<!-- Year -->
+					<!-- {{ param }} -->
 					<td class="">
 						<input {% if not can_edit %}disabled{% endif %} type="number" class="dynamic_year_input form-control parameter-year parameter-year-existing" value="{{ param.year }}" data-value="{{ param.year }}" {% if param.level == level %}name="edit[parameter_instance][{{ param.id }}][year]"{% else %}name="add[{{ param.parameter_id }}][year][]"{% endif %}>
 					</td>
@@ -166,15 +167,14 @@
 						<input {% if not can_edit %}disabled{% endif %} 
 							   type="number" 
 							   class="dynamic_build_year_offset_input form-control parameter-build-year-offset parameter-build-year-offset-existing" 
-							   value="{{ param.build_year_offset }}" 
-							   data-value="{{ param.build_year_offset }}" 
+							   value="{{ param.build_year_offset|default_if_none:'' }}" 
+							   data-value="{{ param.build_year_offset|default_if_none:'' }}" 
 							   {% if param.level == level %}
-								   name="edit[parameter_instance][{{ param.id }}][build_year_offset]"
+								 name="edit[parameter_instance][{{ param.id }}][build_year_offset]"
 							   {% else %}
-								   name="add[{{ param.parameter_id }}][build_year_offset][]"
+								 name="add[{{ param.parameter_id }}][build_year_offset][]"
 							   {% endif %}>
-					</td>
-															<!-- Value -->
+					  </td>
 					<td class="centered">
 						{% if param.choices or param.parameter_is_carrier %}
 						<select {% if not can_edit %}disabled{% endif %} class="dynamic_value_input form-control parameter-value parameter-value-existing" {% if param.level == level %}name="edit[parameter_instance][{{ param.id }}][value]"{% else %}name="add[{{ param.parameter_id }}][value][]"{% endif %} data-value="{{ param.value }}">

From 521966bd4bebd295fb0b82d512d3fedb0b7fac9f Mon Sep 17 00:00:00 2001
From: jeisenma <Jordan.Eisenman@nrel.gov>
Date: Wed, 18 Sep 2024 13:24:32 -0600
Subject: [PATCH 3/6] fixing loc tech and tech classes

---
 calliope_app/api/models/configuration.py      | 77 ++++++++++++-------
 .../client/component_views/configuration.py   |  9 +--
 .../templates/technology_parameters.html      |  1 -
 3 files changed, 53 insertions(+), 34 deletions(-)

diff --git a/calliope_app/api/models/configuration.py b/calliope_app/api/models/configuration.py
index b306a3bc..f8bcf600 100644
--- a/calliope_app/api/models/configuration.py
+++ b/calliope_app/api/models/configuration.py
@@ -827,14 +827,14 @@ def duplicate(self, model_id, pretty_name):
             tech_param.save()
         new_tech.update_calliope_pretty_name()
         return new_tech
-    
 
     def update(self, form_data):
         """ Update the Technology parameters stored in Tech_Param """
         METHODS = ['essentials', 'add', 'edit', 'delete']
+        print(form_data)
         for method in METHODS:
             if method in form_data.keys():
-                data = form_data[method]
+                data = form_data[method]                
                 getattr(Tech_Param, '_' + method)(self, data)
 
 
@@ -935,11 +935,11 @@ def _cplus_carriers(cls, technology, carriers, ratios):
     def _add(cls, technology, data):
         """ Add a new parameter to a technology """
         for key, value_dict in data.items():
-            if all(field in value_dict for field in ['year', 'value', 'build_year_offset']):
+            if (('year' in value_dict) & ('value' in value_dict)):
                 years = value_dict['year']
                 values = value_dict['value']
                 build_year_offsets = value_dict['build_year_offset']
-                num_records = min(len(years), len(values), len(build_year_offsets))
+                num_records = np.min([len(years), len(values)])
                 new_objects = []
                 for i in range(num_records):
                     vals = str(values[i]).split('||')
@@ -950,30 +950,55 @@ def _add(cls, technology, data):
                         build_year_offset=build_year_offsets[i],
                         parameter_id=key,
                         value=ParamsManager.clean_str_val(vals[0]),
-                        raw_value=vals[1] if len(vals) > 1 else vals[0]
-                    ))
+                        raw_value=vals[1] if len(vals) > 1 else vals[0]))
                 cls.objects.bulk_create(new_objects)
+
     @classmethod
     def _edit(cls, technology, data):
+        """ Edit a technology's parameters """
+        if 'parameter' in data:
+            for key, value in data['parameter'].items():
+                vals = str(value).split('||')
+                cls.objects.filter(
+                    model_id=technology.model_id,
+                    technology_id=technology.id,
+                    parameter_id=key).hard_delete()
+                cls.objects.create(
+                    model_id=technology.model_id,
+                    technology_id=technology.id,
+                    parameter_id=key,
+                    value=ParamsManager.clean_str_val(vals[0]),
+                    raw_value=vals[1] if len(vals) > 1 else vals[0])
+        if 'timeseries' in data:
+            for key, value in data['timeseries'].items():
+                cls.objects.filter(
+                    model_id=technology.model_id,
+                    technology_id=technology.id,
+                    parameter_id=key).hard_delete()
+                cls.objects.create(
+                    model_id=technology.model_id,
+                    technology_id=technology.id,
+                    parameter_id=key,
+                    value=ParamsManager.clean_str_val(value),
+                    timeseries_meta_id=value,
+                    timeseries=True)
         if 'parameter_instance' in data:
-            for param_id, param_data in data['parameter_instance'].items():
-                tech_param = cls.objects.filter(id=param_id, technology=technology).first()
-                if tech_param:
-                    if 'build_year_offset' in param_data:
-                        tech_param.build_year_offset = param_data['build_year_offset']
-                    if 'year' in param_data:
-                        tech_param.year = param_data['year']
-                    if 'value' in param_data:
-                        value = param_data['value']
-                        if '||' in value:
-                            parts = value.split('||')
-                            tech_param.value = parts[0].strip()
-                            tech_param.raw_value = parts[1].strip() if len(parts) > 1 else parts[0].strip()
-                        else:
-                            tech_param.value = value
-                            tech_param.raw_value = value
-                    tech_param.save()
-    
+            instance_items = data['parameter_instance'].items()
+            print("instance_items ", instance_items)
+            for key, value_dict in instance_items:
+                parameter_instance = cls.objects.filter(
+                    model_id=technology.model_id,
+                    id=key)
+                if 'value' in value_dict:
+                    vals = str(value_dict['value']).split('||')
+                    parameter_instance.update(
+                        value=ParamsManager.clean_str_val(vals[0]),
+                        raw_value=vals[1] if len(vals) > 1 else vals[0])
+                if 'year' in value_dict:
+                    parameter_instance.update(year=value_dict['year'])
+                if 'build_year_offset' in value_dict:
+                    parameter_instance.update(build_year_offset=value_dict['build_year_offset'])
+
     @classmethod
     def _delete(cls, technology, data):
         """ Delete a technology's parameters """
@@ -1118,8 +1143,7 @@ def _edit(cls, loc_tech, data):
                 loc_tech_param = cls.objects.filter(id=param_id, loc_tech=loc_tech).first()
                 if loc_tech_param:
                     if 'build_year_offset' in param_data:
-                        build_year_offset = param_data['build_year_offset']
-                        loc_tech_param.build_year_offset = int(build_year_offset) if build_year_offset != '' else None
+                        loc_tech_param.build_year_offset = param_data['build_year_offset']
                     if 'year' in param_data:
                         loc_tech_param.year = param_data['year']
                     if 'value' in param_data:
@@ -1150,7 +1174,6 @@ def _edit(cls, loc_tech, data):
     def _delete(cls, loc_tech, data):
         param_ids = data.get('parameter_instance', [])
         for param_id in param_ids:
-            print(f"Deleting Loc_Tech_Param with id: {param_id}")
             cls.objects.filter(id=param_id, loc_tech=loc_tech).delete()
 
 
diff --git a/calliope_app/client/component_views/configuration.py b/calliope_app/client/component_views/configuration.py
index 06de33ab..649f2b10 100644
--- a/calliope_app/client/component_views/configuration.py
+++ b/calliope_app/client/component_views/configuration.py
@@ -158,7 +158,7 @@ def all_tech_params(request):
 
     for param in parameters:
         param['raw_units'] = param['units']
-        tech_param = Loc_Tech_Param.objects.filter(id=param['id']).first()
+        tech_param = Tech_Param.objects.filter(id=param['id']).first()
         build_year_offset = tech_param.build_year_offset if tech_param else None
         param['build_year_offset'] = build_year_offset
     timeseries = Timeseries_Meta.objects.filter(model=model, failure=False,
@@ -275,6 +275,7 @@ def all_loc_tech_params(request):
     parameters = ParamsManager.all_loc_tech_params(loc_tech)
     timeseries = Timeseries_Meta.objects.filter(model=model, failure=False,
                                                 is_uploading=False)
+
     units_in_ids= ParamsManager.get_tagged_params('units_in')
     units_out_ids= ParamsManager.get_tagged_params('units_out')
 
@@ -295,13 +296,9 @@ def all_loc_tech_params(request):
 
     for param in parameters:
         param['raw_units'] = param['units']
-        loc_tech_param = Loc_Tech_Param.objects.filter(id=param['id']).first()
-        build_year_offset = loc_tech_param.build_year_offset if loc_tech_param else None
-        param['build_year_offset'] = build_year_offset
-    print(parameters)
+
     emissions = ParamsManager.emission_categories()
     # Parameters Table
-    print(loc_tech)
     context = {
         "emissions": emissions,
         "loc_tech": loc_tech,
diff --git a/calliope_app/client/templates/technology_parameters.html b/calliope_app/client/templates/technology_parameters.html
index 471f07f4..32bc8184 100644
--- a/calliope_app/client/templates/technology_parameters.html
+++ b/calliope_app/client/templates/technology_parameters.html
@@ -159,7 +159,6 @@
 				<tr class="param_row param_row_min param_row_{{ param.parameter_id }} {% if param.level == level %}{% if param.parameter_category == 'Costs: Monetary' %}table-success{% elif param.parameter_category in emissions %}table-info{% else %}table-primary{% endif %}{% else %}table-default{% endif %}" data-param_id={{ param.parameter_id }}>
 					<td colspan=3 style="background-color: white;"></td>
 					<!-- Year -->
-					<!-- {{ param }} -->
 					<td class="">
 						<input {% if not can_edit %}disabled{% endif %} type="number" class="dynamic_year_input form-control parameter-year parameter-year-existing" value="{{ param.year }}" data-value="{{ param.year }}" {% if param.level == level %}name="edit[parameter_instance][{{ param.id }}][year]"{% else %}name="add[{{ param.parameter_id }}][year][]"{% endif %}>
 					</td>

From f8c0d570d8f61bbadea5de98f2999d1e975e284c Mon Sep 17 00:00:00 2001
From: jeisenma <Jordan.Eisenman@nrel.gov>
Date: Wed, 18 Sep 2024 17:06:33 -0600
Subject: [PATCH 4/6] fixing comment

---
 calliope_app/api/models/configuration.py      |  5 +--
 calliope_app/api/views/configuration.py       | 41 +++++++++++++++----
 .../client/component_views/configuration.py   |  3 --
 3 files changed, 36 insertions(+), 13 deletions(-)

diff --git a/calliope_app/api/models/configuration.py b/calliope_app/api/models/configuration.py
index f8bcf600..dcfe7c3f 100644
--- a/calliope_app/api/models/configuration.py
+++ b/calliope_app/api/models/configuration.py
@@ -984,7 +984,6 @@ def _edit(cls, technology, data):
                     timeseries=True)
         if 'parameter_instance' in data:
             instance_items = data['parameter_instance'].items()
-            print("instance_items ", instance_items)
             for key, value_dict in instance_items:
                 parameter_instance = cls.objects.filter(
                     model_id=technology.model_id,
@@ -1125,7 +1124,6 @@ def _add(cls, loc_tech, data):
                         clean_value, raw_value = value.split('||')
                     else:
                         clean_value = raw_value = value
-                    
                     new_objects.append(cls(
                         model_id=loc_tech.model.id,
                         loc_tech=loc_tech,
@@ -1444,7 +1442,7 @@ def get_tech_params_dict(level, id, excl_ids=None, systemwide=True):
 
         if level in ['1_tech', '2_loc_tech']:
             values += ["year", "timeseries", "timeseries_meta_id",
-                       "raw_value", "value"]
+                       "raw_value", "value", "build_year_offset"]
 
         # System-Wide Handling
         if systemwide is False:
@@ -1460,6 +1458,7 @@ def get_tech_params_dict(level, id, excl_ids=None, systemwide=True):
                 'id': param["id"] if 'id' in param.keys() else 0,
                 'level': level,
                 'year': param["year"] if 'year' in param.keys() else 0,
+                'build_year_offset': param["build_year_offset"] if "build_year_offset" in param.keys() else 0,
                 'technology_id': technology.id,
                 'parameter_root': param["parameter__root"],
                 'parameter_category': param[parameter__category],
diff --git a/calliope_app/api/views/configuration.py b/calliope_app/api/views/configuration.py
index 53172c7a..781da48d 100644
--- a/calliope_app/api/views/configuration.py
+++ b/calliope_app/api/views/configuration.py
@@ -586,6 +586,35 @@ def delete_technology(request):
     return HttpResponse(json.dumps(payload), content_type="application/json")
 
 
+def format_comment(full_name, data):
+    actions = []
+
+    # Process 'add' actions
+    if 'add' in data:
+        for key, value in data['add'].items():
+            years = value['year']
+            build_year_offsets = value['build_year_offset']
+            values = value['value']
+            for year, offset, val in zip(years, build_year_offsets, values):
+                formatted_val = val.replace("||", " or ")
+                actions.append(f"Added technology with build_year_offset {offset}, value {formatted_val}, year {year}")
+    if 'edit' in data:
+        if 'parameter_instance' in data['edit']:
+            edit_count = len(data['edit']['parameter_instance'])
+            if edit_count > 0:
+                actions.append(f"Edited {edit_count} parameter instance{'s' if edit_count > 1 else ''}")
+    if 'delete' in data:
+        if 'parameter_instance' in data['delete']:
+            delete_count = len(data['delete']['parameter_instance'])
+            if delete_count > 0:
+                actions.append(f"Deleted {delete_count} parameter instance{'s' if delete_count > 1 else ''}")
+    result = f"{full_name} performed the following actions:\n"
+    for action in actions:
+        result += f"* {action}\n"
+
+    return result.strip()
+
+
 @csrf_protect
 def update_tech_params(request):
     """
@@ -607,19 +636,15 @@ def update_tech_params(request):
     technology_id = escape(request.POST["technology_id"])
     form_data = json.loads(request.POST["form_data"])
     escaped_form_data = recursive_escape(form_data)
-
+    print("Escaped form data", escaped_form_data)
     model = Model.by_uuid(model_uuid)
     model.handle_edit_access(request.user)
 
     technology = model.technologies.filter(id=technology_id)
-
     if len(technology) > 0:
         technology.first().update(escaped_form_data)
-        # Log Activity
-        comment = "{} updated the technology: {}.".format(
-            request.user.get_full_name(),
-            technology.first().pretty_name,
-        )
+        comment = format_comment(request.user.get_full_name(), escaped_form_data)
+        # Change this: from what params to this... Move to _add request.user
         Model_Comment.objects.create(model=model, comment=comment, type="edit")
         model.notify_collaborators(request.user)
         model.deprecate_runs(technology_id=technology_id)
@@ -862,6 +887,8 @@ def update_loc_tech_params(request):
     if len(loc_tech) > 0:
         loc_tech.first().update(form_data)
         # Log Activity
+        comment = format_comment(request.user.get_full_name(), form_data)
+        print(comment)
         comment = "{} updated the node: {} ({}) @ {}.".format(
             request.user.get_full_name(),
             loc_tech.first().technology.pretty_name,
diff --git a/calliope_app/client/component_views/configuration.py b/calliope_app/client/component_views/configuration.py
index 649f2b10..f650c6b9 100644
--- a/calliope_app/client/component_views/configuration.py
+++ b/calliope_app/client/component_views/configuration.py
@@ -158,9 +158,6 @@ def all_tech_params(request):
 
     for param in parameters:
         param['raw_units'] = param['units']
-        tech_param = Tech_Param.objects.filter(id=param['id']).first()
-        build_year_offset = tech_param.build_year_offset if tech_param else None
-        param['build_year_offset'] = build_year_offset
     timeseries = Timeseries_Meta.objects.filter(model=model, failure=False,
                                                 is_uploading=False)
 

From 4953d9f5b634d12048895294976d3199ef93c96b Mon Sep 17 00:00:00 2001
From: jeisenma <Jordan.Eisenman@nrel.gov>
Date: Wed, 18 Sep 2024 17:07:50 -0600
Subject: [PATCH 5/6] removing print statements

---
 calliope_app/api/models/configuration.py | 1 -
 calliope_app/api/views/configuration.py  | 2 --
 2 files changed, 3 deletions(-)

diff --git a/calliope_app/api/models/configuration.py b/calliope_app/api/models/configuration.py
index dcfe7c3f..288b6ded 100644
--- a/calliope_app/api/models/configuration.py
+++ b/calliope_app/api/models/configuration.py
@@ -831,7 +831,6 @@ def duplicate(self, model_id, pretty_name):
     def update(self, form_data):
         """ Update the Technology parameters stored in Tech_Param """
         METHODS = ['essentials', 'add', 'edit', 'delete']
-        print(form_data)
         for method in METHODS:
             if method in form_data.keys():
                 data = form_data[method]                
diff --git a/calliope_app/api/views/configuration.py b/calliope_app/api/views/configuration.py
index 781da48d..ce8425fe 100644
--- a/calliope_app/api/views/configuration.py
+++ b/calliope_app/api/views/configuration.py
@@ -636,7 +636,6 @@ def update_tech_params(request):
     technology_id = escape(request.POST["technology_id"])
     form_data = json.loads(request.POST["form_data"])
     escaped_form_data = recursive_escape(form_data)
-    print("Escaped form data", escaped_form_data)
     model = Model.by_uuid(model_uuid)
     model.handle_edit_access(request.user)
 
@@ -888,7 +887,6 @@ def update_loc_tech_params(request):
         loc_tech.first().update(form_data)
         # Log Activity
         comment = format_comment(request.user.get_full_name(), form_data)
-        print(comment)
         comment = "{} updated the node: {} ({}) @ {}.".format(
             request.user.get_full_name(),
             loc_tech.first().technology.pretty_name,

From 6d1c28351a2de3837330d494a539dbf00d64e0dc Mon Sep 17 00:00:00 2001
From: jeisenma <Jordan.Eisenman@nrel.gov>
Date: Wed, 23 Oct 2024 13:51:18 -0600
Subject: [PATCH 6/6] remove log statement

---
 calliope_app/client/static/js/main.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/calliope_app/client/static/js/main.js b/calliope_app/client/static/js/main.js
index 27050e75..1f2ec73a 100644
--- a/calliope_app/client/static/js/main.js
+++ b/calliope_app/client/static/js/main.js
@@ -1164,7 +1164,6 @@ function reconvert_all(load_flg){
 }
 
 function activate_paste(class_name) {
-	console.log(class_name);
 	$(class_name).bind('paste', null, function(e) {
 		var values = e.originalEvent.clipboardData.getData('Text').split(/\s+/),
 			$txt = $(this),