diff --git a/db/00187/AddBreederRole.pm b/db/00187/AddBreederRole.pm
new file mode 100644
index 0000000000..deb8ffe6d4
--- /dev/null
+++ b/db/00187/AddBreederRole.pm
@@ -0,0 +1,77 @@
+#!/usr/bin/env perl
+
+
+=head1 NAME
+
+AddBreederRole
+
+=head1 SYNOPSIS
+
+mx-run AddBreederRole [options] -H hostname -D dbname -u username [-F]
+
+this is a subclass of L<CXGN::Metadata::Dbpatch>
+see the perldoc of parent class for more details.
+
+=head1 DESCRIPTION
+
+This patch adds vendor role on sgn_people.sp_roles
+
+This subclass uses L<Moose>. The parent class uses L<MooseX::Runnable>
+
+=head1 AUTHOR
+
+ Chris Simoes < ccs263@cornell.edu >
+
+=head1 COPYRIGHT & LICENSE
+
+Copyright 2010 Boyce Thompson Institute for Plant Research
+
+This program is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=cut
+
+
+package AddBreederRole;
+
+use Moose;
+
+extends 'CXGN::Metadata::Dbpatch';
+
+
+has '+description' => ( default => <<'' );
+This patch adds vendor role on sgn_people.sp_roles
+
+has '+prereq' => (
+    default => sub {
+        [],
+    },
+  );
+
+sub patch {
+    my $self=shift;
+
+    print STDOUT "Executing the patch:\n " .   $self->name . ".\n\nDescription:\n  ".  $self->description . ".\n\nExecuted by:\n " .  $self->username . " .";
+
+    print STDOUT "\nChecking if this db_patch was executed before or if previous db_patches have been executed.\n";
+
+    print STDOUT "\nExecuting the SQL commands.\n";
+
+
+
+   $self->dbh->do(<<EOSQL);
+--do your SQL here
+--
+INSERT INTO sgn_people.sp_roles(name) VALUES ('breeder');
+
+EOSQL
+
+
+    print "You're done!\n";
+
+}
+
+
+####
+1; #
+####
diff --git a/db/00187/AddValidatePhenotypeCvterm.pm b/db/00187/AddValidatePhenotypeCvterm.pm
new file mode 100644
index 0000000000..70d61a33cd
--- /dev/null
+++ b/db/00187/AddValidatePhenotypeCvterm.pm
@@ -0,0 +1,86 @@
+#!/usr/bin/env perl
+
+
+=head1 NAME
+
+ AddValidatePhenotypeCvterm
+
+=head1 SYNOPSIS
+
+mx-run AddValidadePhenotypeCvterm [options] -H hostname -D dbname -u username [-F]
+
+this is a subclass of L<CXGN::Metadata::Dbpatch>
+see the perldoc of parent class for more details.
+
+=head1 DESCRIPTION
+This patch adds phenotype_property cvterm for storing a suppressed plot phenotype.
+This subclass uses L<Moose>. The parent class uses L<MooseX::Runnable>
+
+=head1 AUTHOR
+
+Chris Simoes <ccs263@cornell.edu>
+
+=head1 COPYRIGHT & LICENSE
+
+Copyright 2010 Boyce Thompson Institute for Plant Research
+
+This program is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=cut
+
+
+package AddValidatePhenotypeCvterm;
+
+use Moose;
+use Bio::Chado::Schema;
+use Try::Tiny;
+extends 'CXGN::Metadata::Dbpatch';
+
+
+has '+description' => ( default => <<'' );
+This patch adds phenotype_property cvterm for storing a suppressed plot phenotype.
+
+has '+prereq' => (
+	default => sub {
+        [],
+    },
+
+  );
+
+sub patch {
+    my $self=shift;
+
+    print STDOUT "Executing the patch:\n " .   $self->name . ".\n\nDescription:\n  ".  $self->description . ".\n\nExecuted by:\n " .  $self->username . " .";
+
+    print STDOUT "\nChecking if this db_patch was executed before or if previous db_patches have been executed.\n";
+
+    print STDOUT "\nExecuting the SQL commands.\n";
+    my $schema = Bio::Chado::Schema->connect( sub { $self->dbh->clone } );
+
+
+    print STDERR "INSERTING CV TERMS...\n";
+
+    my $terms = {
+        'project_property' => [
+            'validated_phenotype',
+        ]
+    };
+
+	foreach my $t (keys %$terms){
+		foreach (@{$terms->{$t}}){
+			$schema->resultset("Cv::Cvterm")->create_with({
+				name => $_,
+				cv => $t
+			});
+		}
+	}
+
+
+print "You're done!\n";
+}
+
+
+####
+1; #
+####
diff --git a/js/source/entries/mixedmodels.js b/js/source/entries/mixedmodels.js
index 7eec211a6c..cb683f3c57 100644
--- a/js/source/entries/mixedmodels.js
+++ b/js/source/entries/mixedmodels.js
@@ -103,10 +103,12 @@ export function init(main_div) {
     $('#mixed_model_analysis_prepare_button').click(function () {
 
         dataset_id = get_dataset_id();
+        var dataset_trait_outliers = $('#dataset_trait_outliers').is(':checked') ? 1 : 0;
+
         if (dataset_id != false) {
             $.ajax({
                 url: '/ajax/mixedmodels/prepare',
-                data: { 'dataset_id': get_dataset_id() },
+                data: { 'dataset_id': get_dataset_id(),'dataset_trait_outliers': dataset_trait_outliers, },
                 success: function (r) {
                     if (r.error) {
                         alert(r.error);
diff --git a/js/source/entries/qualitycontrol.js b/js/source/entries/qualitycontrol.js
new file mode 100755
index 0000000000..802f565015
--- /dev/null
+++ b/js/source/entries/qualitycontrol.js
@@ -0,0 +1,690 @@
+import '../legacy/jquery.js';
+import '../legacy/d3/d3v4Min.js';
+
+var version = '0.01';
+
+export function init(main_div) {
+    if (!(main_div instanceof HTMLElement)) {
+        main_div = document.getElementById(main_div.startsWith("#") ? main_div.slice(1) : main_div);
+    }
+
+    var dataset_id;
+    get_select_box("datasets", "qc_dataset_select", { "checkbox_name": "qc_dataset_select_checkbox" });
+
+    jQuery('#qc_analysis_prepare_button').removeClass('active').addClass('inactive');
+
+    $(document).on('click', 'input[name=select_engine]', function (e) {
+        get_model_string();
+    });
+
+    let outliers = [];
+    var trait_selected;
+    var tempfile;
+    let allData = [];
+    var all_traits;
+
+    $('#qc_analysis_prepare_button').click(function () {
+        dataset_id = get_dataset_id();
+        if (dataset_id != false) {
+            $.ajax({
+                url: '/ajax/qualitycontrol/prepare',
+                data: { 'dataset_id': get_dataset_id() },
+                success: function (r) {
+                    if (r.error) {
+                        alert(r.error);
+                    }  else {
+
+                        if (r.tempfile) {
+                            $('#tempfile').html(r.tempfile);
+                        }
+                        updateBoxplot();
+                }
+            },
+                error: function (jqXHR, textStatus, errorThrown) {
+                    console.error('AJAX request failed: ', textStatus, errorThrown);
+                    alert('Error in AJAX request: ' + errorThrown);
+                }
+            });
+        }
+    });
+    $(function() {
+            var handle = $("#custom-handle");
+            $("#outliers_range").slider({
+                orientation: "horizontal",
+                range: "min",
+                max: 10,
+                min: 0,
+                value: 1.5,
+                step: 0.1,
+                create: function() {
+                    handle.text($(this).slider("value"));
+                },
+                slide: function(event, ui) {
+                    handle.text(ui.value);
+                    isFixedMinMax = false;
+                    updateBoxplot(isFixedMinMax, minVal, maxVal);  // Update the boxplot when the slider value changes
+                }
+            });
+        });
+
+    $('#qc_analysis_prepare_button').click(function () {
+        dataset_id = get_dataset_id();
+        if (dataset_id != false) {
+            $.ajax({
+                url: '/ajax/qualitycontrol/prepare',
+                data: { 'dataset_id': dataset_id },  // No need to call get_dataset_id() again
+                success: function (r) {
+                    if (r.error) {
+                        alert(r.error);
+                    } else {
+                          if (r.selected_variable) {
+                            populateTraitDropdown(r.selected_variable);  // Populate dropdown with traits
+                            all_traits = r.selected_variable;
+                        }
+                        if (r.tempfile) {
+                            $('#tempfile').html(r.tempfile);
+                        }
+                    }
+                },
+                error: function (jqXHR, textStatus, errorThrown) {
+                    alert('Error in AJAX request: ' + errorThrown);
+                }
+            });
+        }
+    });
+
+    let isFixedMinMax = false;
+    let minVal;
+    let maxVal;
+    
+    $('#selected_variable').on('change', function () {
+        trait_selected = $('#trait_select').val();  // Get the selected trait from the dropdown
+
+        if (!trait_selected) {
+            $('#trait_boxplot').html('Please select a trait to see the boxplot!');
+            return;
+        }
+
+        // Fetch tempfile value
+        tempfile = $('#tempfile').html();  
+
+        // Check if tempfile is not empty
+        if (!tempfile || tempfile.trim() === '') {
+            return; // Exit if tempfile is empty
+        }
+
+        var outlierMultiplier = $('#outliers_range').slider("value");
+        if (!outlierMultiplier || isNaN(outlierMultiplier)) {
+            outlierMultiplier = 1.5;         }
+
+        $.ajax({
+            url: '/ajax/qualitycontrol/grabdata',
+            data: { 'file': tempfile, 'trait': trait_selected },
+            success: function (r) {
+                $('#working_modal').modal("hide");
+                if (r.message) {
+                    alert(r.message);
+                    return;
+                } else {
+                    const result = drawBoxplot(r.data, trait_selected, outlierMultiplier, isFixedMinMax, minVal, maxVal );
+                    outliers = result.outliers;  // Extract the outliers
+                    allData = r.data;
+                    populateOutlierTable(r.data, trait_selected);
+                    populateCleanTable(r.data, outliers, trait_selected);
+                }
+                
+            },
+            error: function (e) {
+                alert('Error during AJAX request!');
+            }
+        });
+
+    });
+    
+    $("#fixed-min-max").click(function() {
+        isFixedMinMax = true;  
+
+        let dataset_id = get_dataset_id();
+        minVal = parseFloat(document.getElementById("min-limit").value);
+        maxVal = parseFloat(document.getElementById("max-limit").value);
+
+        if (dataset_id) {
+            $.ajax({
+                url: '/ajax/qualitycontrol/prepare',
+                data: { 'dataset_id': dataset_id },
+                success: function (r) {
+                    if (r.error) {
+                        alert(r.error);
+                    } else {
+                        if (r.selected_variable) {
+                            updateBoxplot(isFixedMinMax, minVal, maxVal);
+                        }
+                        if (r.tempfile) {
+                            $('#tempfile').html(r.tempfile);
+                        }
+                    }
+                },
+                error: function (jqXHR, textStatus, errorThrown) {
+                    alert('Error in AJAX request: ' + errorThrown);
+                }
+            });
+        }
+    });
+    
+    const checkedTraits = [];
+    $('#select_traits_button').on('click', function () {
+        populateOtherTraits(all_traits, trait_selected);
+        $(document).on('change', 'input[name="new_trait_options"]', function() {
+            $('input[name="new_trait_options"]:checked').each(function() {
+                checkedTraits.push($(this).val());  // Get the value of each checked checkbox
+            });
+        });
+    });
+
+        
+    $('#store_outliers_button').click(function () {
+        console.log("The other is:", checkedTraits);
+        $.ajax({
+            url: '/ajax/qualitycontrol/storeoutliers',  
+            method: "POST",  
+            data: {"outliers": JSON.stringify(outliers), "othertraits": JSON.stringify(checkedTraits)
+            },
+            success: function(response) {
+                if(response.is_curator === 1) {
+                    $('#store_outliers_button').prop("disabled", false);
+                    alert('Outliers successfully stored!');
+                } else {
+                    $('#store_outliers_button').prop("disabled", true);
+                    alert("Only curators or breeders are allowed to validated trials. Please contact a curator.", response.is_curator);
+                }
+                
+
+            },
+            error: function(xhr, status, error) {
+                alert('Error saving outliers: ' + error);
+                console.log(xhr, status);
+            }
+        });
+    });
+
+    $('#restore_outliers_button').click(function () {
+        $.ajax({
+            url: '/ajax/qualitycontrol/datarestore',
+            data: { 'file': tempfile, 'trait': trait_selected },
+            success: function (r) {
+                $('#working_modal').modal("hide");
+                if (r.message) {
+                    alert(r.message); 
+                    return;
+                } else {
+                    var trialNames = r.data;
+                    $.ajax({
+                        url: '/ajax/qualitycontrol/restoreoutliers',
+                        method: "POST",
+                        data: {"outliers": JSON.stringify(trialNames), "trait":trait_selected,
+                        },
+                        success: function (r) {
+                            if (r.is_curator === 1) {
+                                $('#restore_outliers_button').prop("disabled", false);
+                                alert("Data successfully restored!");
+                            } else {
+                                $('#restore_outliers_button').prop("disabled", true);
+                                alert("Only curators are allowed undo validated trial. Please contact a curator.");
+                            }
+                        },
+                        error: function () {
+                            alert('Error during restore!');
+                        }
+                    });
+                }
+            },
+            error: function () {
+                alert('Error during AJAX request!');
+            }
+        });
+    });
+
+}
+
+function populateOtherTraits(traitsHTML, traitSelected) {
+    const $traitContainer = $('#other_traits');
+    $traitContainer.empty();
+
+    const $traits = $(traitsHTML);  // Parse the HTML into jQuery elements
+    const traitsArray = $traits.map(function() {
+        return $(this).val();  // Get the value of each trait input element
+    }).get();  // Convert jQuery object to a regular array
+
+    const filteredTraits = traitsArray.filter(trait => !traitSelected.includes(trait));
+
+    filteredTraits.forEach(trait => {
+        const $checkbox = $('<input>', {
+            type: 'checkbox',
+            name: 'new_trait_options',
+            value: trait
+        });
+
+        const $label = $('<label>').text(trait);
+
+        const $div = $('<div>').append($checkbox).append($label);
+        $traitContainer.append($div);
+    });
+}
+
+
+function updateBoxplot(isFixed, minValue, maxValue) {
+    // Fetch the selected trait and tempfile
+    var trait_selected = $('#trait_select').val();
+    var tempfile = $('#tempfile').html();
+
+    if (!trait_selected || !tempfile || tempfile.trim() === '') {
+        console.log("Either trait or tempfile is missing!");
+        return;
+    }
+
+    const outlierMultiplier = $("#outliers_range").slider("value") || 1.5;
+
+    // Perform an AJAX call to fetch the actual data
+    $.ajax({
+        url: '/ajax/qualitycontrol/grabdata',  // Adjust this URL if needed
+        data: { 'file': tempfile, 'trait': trait_selected },  // Send both tempfile and trait
+        success: function (response) {
+            const boxplotData = response.data || [];  // Adjust based on the actual response structure
+            drawBoxplot(boxplotData, trait_selected, outlierMultiplier, outlierMultiplier, isFixed, minValue, maxValue);
+            const result = drawBoxplot(boxplotData, trait_selected, outlierMultiplier, isFixed, minValue, maxValue);
+            const outliers = result.outliers || [];
+            populateCleanTable(boxplotData, outliers, trait_selected);
+        },
+
+        error: function (jqXHR, textStatus, errorThrown) {
+            console.error('AJAX request failed: ', textStatus, errorThrown);
+            alert('Error fetching data for boxplot: ' + errorThrown);
+        }
+    });
+}
+
+function calculateStatistics(values) {
+    if (values.length === 0) return { min: null, max: null, sd: null, cv: null };
+
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const mean = values.reduce((acc, val) => acc + val, 0) / values.length;
+    const sd = Math.sqrt(values.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / values.length);
+    const cv = (sd / mean) * 100;
+
+    return { min, max, mean, sd, cv };
+}
+
+
+function populateOutlierTable(data, trait) {
+    const tableBody = document.querySelector("#outlier_table tbody"); 
+
+    tableBody.innerHTML = ''; // Clear existing table content
+    const groupedData = {};
+
+    data.forEach(item => {
+        const valueStr = item[trait] || '';
+        const value = parseFloat(valueStr.replace(',', '.'));
+
+
+        if (item.locationDbId && item.studyName && !isNaN(value)) {
+            const identifier = `${item.locationDbId}-${item.studyName}`;
+
+            if (!groupedData[identifier]) {
+                groupedData[identifier] = {
+                    locationDbId: item.locationDbId,
+                    locationName: item.locationName,
+                    studyName: item.studyName,
+                    values: [] 
+                };
+            }
+            groupedData[identifier].values.push(value);
+        }
+    });
+
+
+    for (const key in groupedData) {
+        const dataGroup = groupedData[key];
+        const stats = calculateStatistics(dataGroup.values); 
+        const row = tableBody.insertRow();
+        const cell1 = row.insertCell(0);
+        const cell2 = row.insertCell(1);
+        const cell3 = row.insertCell(2);
+        const cell4 = row.insertCell(3);
+        const cell5 = row.insertCell(4);
+        const cell6 = row.insertCell(5);
+        const cell7 = row.insertCell(6);
+        const cell8 = row.insertCell(7);
+
+        // Populate the cells with data, checking for null or undefined values
+        cell1.innerHTML = dataGroup.locationDbId || 'N/A';
+        cell2.innerHTML = dataGroup.locationName || 'N/A';
+        cell3.innerHTML = dataGroup.studyName || 'N/A';
+        cell4.innerHTML = stats.min !== null ? stats.min.toFixed(2) : 'N/A';
+        cell5.innerHTML = stats.max !== null ? stats.max.toFixed(2) : 'N/A';
+        cell6.innerHTML = stats.mean !== null ? stats.mean.toFixed(2) : 'N/A';
+        cell7.innerHTML = stats.sd !== null && !isNaN(stats.sd) ? stats.sd.toFixed(2) : 'N/A';
+        cell8.innerHTML = stats.cv !== null && !isNaN(stats.cv) ? stats.cv.toFixed(2) + '%' : 'N/A';
+    }
+}
+
+
+function populateCleanTable(data, outliers, trait) {
+    const tableBody = document.querySelector("#clean_table tbody");
+    tableBody.innerHTML = ''; // Clear existing table content
+
+    // Create a Set of outlier plot names for quick lookup
+    const outlierPlotNames = new Set(outliers.map(outlier => outlier.plotName));
+    const groupedData = {};
+
+    data.forEach(item => {
+        if (outlierPlotNames.has(item.observationUnitName)) {
+            return; // Skip this item if it's an outlier
+        }
+
+        // Extract the value from the specified trait
+        const valueStr = item[trait] || ''; 
+        const value = parseFloat(valueStr.replace(',', '.')); 
+
+        if (item.locationDbId && item.studyName) {
+            const identifier = `${item.locationDbId}-${item.studyName}`;
+            if (!groupedData[identifier]) {
+                groupedData[identifier] = {
+                    locationDbId: item.locationDbId,
+                    locationName: item.locationName,
+                    studyName: item.studyName,
+                    values: []
+                };
+            }
+            groupedData[identifier].values.push(value);
+        }
+    });
+
+    for (const key in groupedData) {
+        const dataGroup = groupedData[key];
+        const stats = calculateStatistics(dataGroup.values); 
+        const row = tableBody.insertRow();
+        const cell1 = row.insertCell(0);
+        const cell2 = row.insertCell(1);
+        const cell3 = row.insertCell(2);
+        const cell4 = row.insertCell(3);
+        const cell5 = row.insertCell(4);
+        const cell6 = row.insertCell(5);
+        const cell7 = row.insertCell(6);
+        const cell8 = row.insertCell(7);
+
+        // Populate the cells with data, checking for null or undefined values
+        cell1.innerHTML = dataGroup.locationDbId || 'N/A';
+        cell2.innerHTML = dataGroup.locationName || 'N/A';
+        cell3.innerHTML = dataGroup.studyName || 'N/A';
+        cell4.innerHTML = stats.min !== null ? stats.min.toFixed(2) : 'N/A';
+        cell5.innerHTML = stats.max !== null ? stats.max.toFixed(2) : 'N/A';
+        cell6.innerHTML = stats.mean !== null ? stats.mean.toFixed(2) : 'N/A';
+        cell7.innerHTML = stats.sd !== null && !isNaN(stats.sd) ? stats.sd.toFixed(2) : 'N/A';
+        cell8.innerHTML = stats.cv !== null && !isNaN(stats.cv) ? stats.cv.toFixed(2) + '%' : 'N/A';
+    }
+}
+
+
+
+function drawBoxplot(data, selected_trait, outlierMultiplier, isFixedMinMax, minVal, maxVal) {
+  const groupedData = d3.nest()
+    .key(d => d.locationDbId)
+    .entries(data);
+  if (outlierMultiplier === null) { outlierMultiplier = 1.5; }
+
+  let allOutliers = [];
+
+  const boxplotData = groupedData.map(group => {
+    const values = group.values.map(d => parseFloat(d[selected_trait])).filter(d => d != null && !isNaN(d));
+
+    if (values.length < 4) {
+      return {
+        locationDbId: group.key,
+        values: [],
+        outliers: [],
+        q1: null,
+        q3: null,
+        iqr: null,
+        lowerBound: null,
+        upperBound: null,
+        min: null,
+        max: null,
+        median: null
+      };
+    }
+
+    values.sort(d3.ascending);
+    const q1 = d3.quantile(values, 0.25);
+    const q3 = d3.quantile(values, 0.75);
+    const iqr = Math.max(0, q3 - q1);
+
+    // Calculate lower and upper bounds based on isFixedMinMax
+    let lowerBound, upperBound;
+    if (isFixedMinMax) {
+      // Use the provided minVal and maxVal for all locations
+      lowerBound = minVal;
+      upperBound = maxVal;
+    } else {
+      lowerBound = q1 - outlierMultiplier * iqr;
+      upperBound = q3 + outlierMultiplier * iqr;
+    }
+    
+
+    const median = d3.quantile(values, 0.5);
+
+    const outliers = values.filter(v => v < lowerBound || v > upperBound);
+
+    const groupOutliers = outliers.flatMap(value => {
+      return group.values
+        .filter(v => parseFloat(v[selected_trait]) === value)
+        .map(match => ({
+          locationDbId: group.key,
+          studyName: match.studyName,
+          locationName: match.locationName,
+          plotName: match.observationUnitName,
+          trait: selected_trait,
+          value: value
+        }));
+    });
+
+    allOutliers = allOutliers.concat(groupOutliers);
+
+    return {
+      locationDbId: group.key,
+      values,
+      outliers,
+      q1,
+      q3,
+      iqr,
+      lowerBound,
+      upperBound,
+      min: d3.min(values),
+      max: d3.max(values),
+      median
+    };
+  });
+
+
+    // Drawing the boxplot
+    const margin = {top: 10, right: 30, bottom: 50, left: 40},
+          width = 800 - margin.left - margin.right,
+          height = 400 - margin.top - margin.bottom;
+
+    d3.select("#trait_boxplot").select("svg").remove();
+    
+    const svg = d3.select("#trait_boxplot")
+        .append("svg")
+        .attr("width", width + margin.left + margin.right)
+        .attr("height", height + margin.top + margin.bottom)
+        .append("g")
+        .attr("transform", "translate(" + margin.left + "," + margin.top + ")");
+
+    const x = d3.scaleLinear()
+    .domain([d3.min(boxplotData, d => d.min), d3.max(boxplotData, d => d.max)])
+    .range([0, width]);
+
+    const y = d3.scaleBand()
+        .domain(boxplotData.map(d => d.locationDbId))
+        .range([0, height])
+        .padding(0.1);
+
+    const boxWidth = y.bandwidth() / 2; 
+
+    const boxplotGroup = svg.selectAll(".boxplot")
+        .data(boxplotData.filter(d => d.values.length > 0)) // Skip empty groups
+        .enter().append("g")
+        .attr("class", "boxplot")
+        .attr("transform", d => "translate(0," + (y(d.locationDbId) + y.bandwidth() / 2) + ")");
+
+    // Draw boxes
+    boxplotGroup.append("rect")
+        .attr("x", d => x(d.q1))
+        .attr("y", -boxWidth / 2)
+        .attr("width", d => x(d.q3) - x(d.q1))
+        .attr("height", boxWidth)
+        .attr("stroke", "black")
+        .attr("fill", "#9c9ede");
+
+    // Draw median line
+    boxplotGroup.append("line")
+        .attr("x1", d => x(d.median))
+        .attr("x2", d => x(d.median))
+        .attr("y1", -boxWidth / 2)
+        .attr("y2", boxWidth / 2)
+        .attr("stroke", "black");
+
+    // Draw whiskers
+    boxplotGroup.append("line")
+        .attr("x1", d => x(d.min))
+        .attr("x2", d => x(d.max))
+        .attr("y1", 0)
+        .attr("y2", 0)
+        .attr("stroke", "black");
+
+    // X-axis
+    svg.append("g")
+        .attr("transform", `translate(0,${height})`) // Position at the bottom
+        .call(d3.axisBottom(x))
+        .selectAll("text") // Add rotation if labels overlap
+        .attr("transform", "translate(0,5)")
+        .style("text-anchor", "middle");
+
+    // X-axis label
+    svg.append("text")
+        .attr("class", "x-label")
+        .attr("text-anchor", "middle")
+        .attr("x", width / 2)
+        .attr("y", height + margin.bottom - 10) // Ensure it's visible within margins
+        .text(selected_trait); // Add trait name
+
+    // Y-axis
+    svg.append("g")
+        .call(d3.axisLeft(y));
+
+    // Y-axis label
+    svg.append("text")
+        .attr("class", "y-label")
+        .attr("text-anchor", "middle")
+        .attr("x", -height / 2) // Position in the center of the Y-axis
+        .attr("y", -margin.left + 10) // Ensure it's within margins
+        .attr("transform", "rotate(-90)") // Rotate to match Y-axis orientation
+        .text("Location ID");
+
+
+    // Draw individual points with jitter
+    const pointGroup = svg.selectAll(".point")
+        .data(boxplotData.filter(d => d.values.length > 0)) // Skip empty groups
+        .enter().append("g")
+        .attr("class", "point")
+        .attr("transform", d => "translate(0," + y(d.locationDbId) + ")");
+
+    // Create a tooltip div
+    const tooltip = d3.select("body").append("div")
+        .attr("class", "tooltip")
+        .style("opacity", 0)
+        .style("position", "absolute") // Ensure it's positioned relative to the cursor
+        .style("background", "#fff") // Tooltip background color
+        .style("border", "1px solid #ccc") // Border for better visibility
+        .style("border-radius", "4px")
+        .style("padding", "5px") // Add padding for text readability
+        .style("pointer-events", "none"); // Prevent mouse interaction with the tooltip
+
+    // Draw circles for all points (including outliers)
+    pointGroup.selectAll("circle")
+        .data(d => d.values.map((value, index) => ({
+            value: value,
+            isOutlier: value < d.lowerBound || value > d.upperBound, // Check for outliers
+            plotName: d.plotName // Ensure this is correct
+        })))
+        .enter().append("circle")
+        .attr("cx", d => x(d.value))
+        .attr("cy", d => (Math.random() - 0.5) * boxWidth + boxWidth / 2) // Center and add jitter
+        .attr("r", 3) // Set a fixed radius for points
+        .attr("fill", d => d.isOutlier ? "#d9534f" : "#5cb85c") // Outliers are red, non-outliers are green
+        .on("mouseover", function(event, d) {
+            tooltip.transition()
+                .duration(200)
+                .style("opacity", .9); // Fade in the tooltip
+
+            // Add plotName and value to the tooltip content
+            tooltip.html(`<strong>Plot:</strong> ${d.plotName}<br><strong>Value:</strong> ${d.value}`)
+                .style("left", (event.pageX + 10) + "px") // Position tooltip near the cursor
+                .style("top", (event.pageY - 28) + "px");
+        })
+        .on("mouseout", function(d) {
+            tooltip.transition()
+                .duration(500)
+                .style("opacity", 0); // Fade out the tooltip
+        });
+
+
+
+
+    // Return both the boxplot data and the outliers
+    return {
+        boxplotData: boxplotData,
+        outliers: allOutliers
+    };
+
+}
+
+
+
+function get_dataset_id() {
+    var selected_datasets = [];
+    jQuery('input[name="qc_dataset_select_checkbox"]:checked').each(function () {
+        selected_datasets.push(jQuery(this).val());
+    });
+    if (selected_datasets.length < 1) {
+        alert('Please select at least one dataset!');
+        return false;
+    } else if (selected_datasets.length > 1) {
+        alert('Please select only one dataset!');
+        return false;
+    } else {
+        var dataset_id = selected_datasets[0];
+        return dataset_id;
+    }
+}
+
+function populateTraitDropdown(selectedVariableHTML) {
+    var traitSelect = $('#trait_select');  // Dropdown element
+    traitSelect.empty();  // Clear previous options
+
+    // Add default "Select a trait" option
+    traitSelect.append('<option disabled selected value="">Select a trait</option>');
+
+    // Create a temporary div to hold the HTML string
+    var tempDiv = $('<div>').html(selectedVariableHTML);
+
+    // Extract values from the checkboxes in the HTML
+    tempDiv.find('input.trait_box').each(function () {
+        var traitValue = $(this).val(); 
+        traitSelect.append($('<option>', {
+            value: traitValue,  
+            text: traitValue    
+        }));
+    });
+}
+
diff --git a/lib/CXGN/Phenotypes/Search/MaterializedViewTable.pm b/lib/CXGN/Phenotypes/Search/MaterializedViewTable.pm
index 58f80dd90d..5d0833c09d 100644
--- a/lib/CXGN/Phenotypes/Search/MaterializedViewTable.pm
+++ b/lib/CXGN/Phenotypes/Search/MaterializedViewTable.pm
@@ -329,9 +329,15 @@ sub search {
     #     push @where_clause, 'JSON_EXISTS(observations, \'$[*] ? (@.value >= '.$self->phenotype_min_value.' && @.value <= '.$self->phenotype_max_value.')\')';
     # }
     #
-    #if ($self->exclude_phenotype_outlier){
-    #    push @where_clause, "observations !@> '[{\"outlier\" : 1}]'";;
-    #}
+    if ($self->exclude_phenotype_outlier){
+        push @where_clause, "NOT EXISTS (
+        SELECT 1
+        FROM phenotypeprop p
+        JOIN nd_experiment_phenotype nep ON p.phenotype_id = nep.phenotype_id
+        JOIN nd_experiment_stock nes ON nes.nd_experiment_id = nep.nd_experiment_id
+        WHERE nes.stock_id = materialized_phenotype_jsonb_table.observationunit_stock_id
+        )";
+    }
 
     my $where_clause = " WHERE " . (join (" AND " , @where_clause));
     my $or_clause = '';
diff --git a/lib/SGN/Controller/AJAX/Heritability.pm b/lib/SGN/Controller/AJAX/Heritability.pm
index d0b318ed59..ac25425f94 100644
--- a/lib/SGN/Controller/AJAX/Heritability.pm
+++ b/lib/SGN/Controller/AJAX/Heritability.pm
@@ -50,7 +50,7 @@ sub shared_phenotypes: Path('/ajax/heritability/shared_phenotypes') : {
 
     my $temppath = $c->config->{basepath}."/".$tempfile;
     print STDERR "***** temppath = $temppath\n";
-    my $ds2 = CXGN::Dataset::File->new(people_schema => $people_schema, schema => $schema, sp_dataset_id => $dataset_id, exclude_dataset_outliers => $exclude_outliers, file_name => $temppath, quotes => 0);
+    my $ds2 = CXGN::Dataset::File->new(people_schema => $people_schema, schema => $schema, sp_dataset_id => $dataset_id, exclude_dataset_outliers => $exclude_outliers, exclude_phenotype_outlier => $exclude_outliers, file_name => $temppath, quotes => 0);
     my $phenotype_data_ref = $ds2->retrieve_phenotypes();
 
     print STDERR Dumper(@trait_info);
@@ -142,7 +142,7 @@ sub generate_results: Path('/ajax/heritability/generate_results') : {
     #my $temppath = $heritability_tmp_output . "/" . $tempfile;
     my $temppath = $tempfile;
 
-    my $ds = CXGN::Dataset::File->new(people_schema => $people_schema, schema => $schema, sp_dataset_id => $dataset_id, exclude_dataset_outliers => $exclude_outliers, file_name => $temppath, quotes => 0);
+    my $ds = CXGN::Dataset::File->new(people_schema => $people_schema, schema => $schema, sp_dataset_id => $dataset_id, exclude_dataset_outliers => $exclude_outliers, exclude_phenotype_outlier => $exclude_outliers, file_name => $temppath, quotes => 0);
 
     my $phenotype_data_ref = $ds->retrieve_phenotypes($pheno_filepath);
 
diff --git a/lib/SGN/Controller/AJAX/MixedModels.pm b/lib/SGN/Controller/AJAX/MixedModels.pm
index 2289ade639..81606a36c6 100644
--- a/lib/SGN/Controller/AJAX/MixedModels.pm
+++ b/lib/SGN/Controller/AJAX/MixedModels.pm
@@ -87,6 +87,7 @@ sub prepare: Path('/ajax/mixedmodels/prepare') Args(0) {
     my $self = shift;
     my $c = shift;
     my $dataset_id = $c->req->param('dataset_id');
+    my $exclude_outliers = $c->req->param('dataset_trait_outliers');
 
     if (! $c->user()) {
         $c->stash->{rest} = {error=>'You must be logged in first!'};
@@ -101,7 +102,7 @@ sub prepare: Path('/ajax/mixedmodels/prepare') Args(0) {
     my $schema = $c->dbic_schema("Bio::Chado::Schema", "sgn_chado");
     my $temppath = $c->config->{basepath}."/".$tempfile;
 
-    my $ds = CXGN::Dataset::File->new(people_schema => $people_schema, schema => $schema, sp_dataset_id => $dataset_id, file_name => $temppath, quotes => 0);
+    my $ds = CXGN::Dataset::File->new(people_schema => $people_schema, schema => $schema, sp_dataset_id => $dataset_id,exclude_dataset_outliers => $exclude_outliers, exclude_phenotype_outlier => $exclude_outliers, file_name => $temppath, quotes => 0);
     $ds->retrieve_phenotypes();
 
     # Note: file is cleaned by run_model function in CXGN::MixedModel
diff --git a/lib/SGN/Controller/AJAX/QualityControl.pm b/lib/SGN/Controller/AJAX/QualityControl.pm
index 5487f76fd6..51d2024d8b 100644
--- a/lib/SGN/Controller/AJAX/QualityControl.pm
+++ b/lib/SGN/Controller/AJAX/QualityControl.pm
@@ -1,450 +1,437 @@
+
 package SGN::Controller::AJAX::QualityControl;
 
 use Moose;
-use namespace::autoclean;
-
-use Carp qw/ carp confess croak /;
-use Cache::File;
-use CXGN::Tools::Run;
-use File::Temp qw / tempfile tempdir /;
-use File::Spec::Functions qw / catfile catdir/;
-use File::Slurp qw /write_file read_file/;
-use File::Path qw / mkpath  /;
-use File::Copy;
-use File::Basename;
-use CXGN::Phenome::Population;
+
+use Data::Dumper;
+use File::Slurp;
+use File::Spec qw | catfile |;
+use File::Path qw(rmtree);
+use JSON::Any;
+use File::Basename qw | basename |;
+use DateTime;
+use Bio::Chado::Schema;
+use CXGN::Dataset::File;
+use CXGN::Phenotypes::File;
+use CXGN::MixedModels;
+use SGN::Controller::AJAX::Dataset;
 use JSON;
-use Try::Tiny;
-use Scalar::Util qw /weaken reftype/;
-use Storable qw/ nstore retrieve /;
-BEGIN { extends 'Catalyst::Controller' }
 
 
-sub check_pheno_qc_result :Path('/phenotype/qualityControl/check/result/') Args(1) {
-    my ($self, $c, $pop_id) = @_;
+BEGIN { extends 'Catalyst::Controller::REST' };
 
-    $c->stash->{pop_id} = $pop_id;
+__PACKAGE__->config(
+    default => 'application/json',
+    stash_key => 'rest',
+    map => { 'application/json' => 'JSON' },
+   );
 
-    $self->pheno_qualityControl_output_files($c);
-    my $qc_output_file = $c->stash->{qc_messages_json_file};
 
-    my $ret->{result} = undef;
+sub prepare: Path('/ajax/qualitycontrol/prepare') Args(0) {
+    my $self = shift;
+    my $c = shift;
+    my $dataset_id = $c->req->param('dataset_id');
 
-    if (-s $qc_output_file && $pop_id =~ /\d+/)
-    {
-    $ret->{result} = 1;
+    if (! $c->user()) {
+        $c->stash->{rest} = {error=>'You must be logged in first!'};
+        $c->detach;
     }
 
-    $ret = to_json($ret);
+    $c->tempfiles_subdir("qualitycontrol");
 
-    $c->res->content_type('application/json');
-    $c->res->body($ret);
+    my ($fh, $tempfile) = $c->tempfile(TEMPLATE=>"qualitycontrol/qc_XXXXX");
 
-}
+    my $people_schema = $c->dbic_schema("CXGN::People::Schema");
+    my $schema = $c->dbic_schema("Bio::Chado::Schema", "sgn_chado");
+    my $temppath = $c->config->{basepath}."/".$tempfile;
 
+    my $ds = CXGN::Dataset::File->new(people_schema => $people_schema, schema => $schema, sp_dataset_id => $dataset_id, exclude_dataset_outliers => 1, file_name => $temppath, quotes => 0);
+    $ds->retrieve_phenotypes();
+    my $pf = CXGN::Phenotypes::File->new( { file => $temppath."_phenotype.txt" });
 
-sub qualityControl_phenotype_data :Path('/qualityControl/phenotype/data/') Args(0) {
-    my ($self, $c) = @_;
-
-    my $pop_id = $c->req->param('population_id');
-    $c->stash->{pop_id} = $pop_id;
+    # my @traits_select = ();
+    my $traits = $pf->traits();
 
-    my $referer = $c->req->referer;
+    my $trait_options = "trait_options";
+    my $trait_html ="";
 
-    my $phenotype_file;
-
-    if ($referer =~ /qtl/)
-    {
-    my $phenotype_dir = $c->stash->{solqtl_cache_dir};
-        $phenotype_file   = 'phenodata_' . $pop_id;
-        $phenotype_file   = $c->controller('solGS::Files')->grep_file($phenotype_dir, $phenotype_file);
-    }
-    else
-    {
-    $c->controller('solGS::Files')->phenotype_file_name($c, $pop_id);
-    $phenotype_file = $c->stash->{phenotype_file_name};
+    foreach my $trait (@$traits) {
+       if ($trait =~ m/.+\d{7}/){
+        $trait_html .= '<input type="checkbox" class= "trait_box" name="'.$trait_options.'" value="'.$trait.'">'.$trait.'</input> </br>';
+       }
     }
 
-    unless (-s $phenotype_file)
-    {
-        $self->create_qualityControl_phenodata_file($c);
-        $phenotype_file =  $c->stash->{phenotype_file_name};
-    }
 
-    my $ret->{result} = undef;
-
-    if (-s $phenotype_file)
-    {
-        $ret->{result} = 1;
-    }
-
-    $ret = to_json($ret);
-
-    $c->res->content_type('application/json');
-    $c->res->body($ret);
+    $c->stash->{rest} = {
+        selected_variable => $trait_html,
+        tempfile => $tempfile."_phenotype.txt",
+    };
 
 }
 
+sub extract_trait_data :Path('/ajax/qualitycontrol/grabdata') Args(0) {
+    my $self = shift;
+    my $c = shift;
+    my $dbh = $c->dbc->dbh();
+    my $schema = $c->dbic_schema("Bio::Chado::Schema");
 
+    my $file = $c->req->param("file");
+    my $trait = $c->req->param("trait");
 
-sub trait_acronyms {
-    my ($self, $c) = @_;
-
-    my $pop_id = $c->stash->{pop_id};
-    $c->controller('solGS::Trait')->get_all_traits($c, $pop_id);
-    $c->controller('solGS::Trait')->get_acronym_pairs($c, $pop_id);
-
-}
-
-
-sub create_qualityControl_phenodata_file {
-    my ($self, $c)  = @_;
+    $file = basename($file);
 
-    my $referer = $c->req->referer;
+    my $temppath = File::Spec->catfile($c->config->{basepath}, "static/documents/tempfiles/qualitycontrol/".$file);
+    my $F;
+    if (! open($F, "<", $temppath)) {
+    $c->stash->{rest} = { error => "Can't find data." };
+    return;
+    }
 
-    my $phenotype_file;
-    my $pop_id = $c->stash->{pop_id};
+    my $header = <$F>;
+    chomp($header);
 
-    if ($referer =~ /qtl/)
-    {
-        my $pheno_exp = "phenodata_${pop_id}";
-        my $dir       = $c->stash->{solqtl_cache_dir};
+    my @keys = split("\t", $header);
 
-        $phenotype_file = $c->controller('solGS::Files')->grep_file($dir, $pheno_exp);
+    my @data = ();
 
-        unless ($phenotype_file)
-    {
-            my $pop =  CXGN::Phenome::Population->new($c->dbc->dbh, $pop_id);
-            $phenotype_file =  $pop->phenotype_file($c);
+    while (<$F>) {
+        chomp;
+        my @fields = split "\t";
+        my %line = ();
+        
+        for (my $n = 0; $n < @keys; $n++) {
+            if (exists($fields[$n]) && defined($fields[$n])) {
+                $line{$keys[$n]} = $fields[$n];
+            }
+        }
+        if (defined $line{$trait} && $line{$trait} ne '') {
+            push @data, \%line;
         }
-
     }
-    else
-    {
-    $self->qc_pheno_query_jobs_file($c);
-    my $queries =$c->stash->{qc_pheno_query_jobs_file};
-
-    $c->stash->{dependent_jobs} = $queries;
-    $c->controller('solGS::solGS')->run_async($c);
-
-    $c->controller("solGS::Files")->phenotype_file_name($c, $pop_id);
-    $phenotype_file = $c->stash->{phenotype_file_name};
+    
+    my %unique_names;
+    foreach my $entry (@data) {
+        if (defined $entry->{'studyName'} && $entry->{'studyName'} ne '') {
+            $unique_names{$entry->{'studyName'}} = 1;
+        }
     }
 
+    # Format the unique project names for the SQL query
+    
+    $trait =~ s/\|.*//;
+    my $trait_like = $trait . '%';
+    
+    my $project_names = join(", ", map { "'$_'" } keys %unique_names);
+
+    my $trait_sql = qq{
+        select project."name" from projectprop
+        join project on project.project_id = projectprop.project_id 
+        where projectprop.type_id = (select cvterm_id from cvterm where cvterm."name" = 'validated_phenotype')
+        and project.name in ($project_names)
+        and projectprop.value like '$trait_like'
+        group by project."name";
+    };
+
+    my @validated_projects;
+    eval {
+        # Prepare and execute the query
+        my $sth_trait = $dbh->prepare($trait_sql);
+        $sth_trait->execute();
+
+        # Collect project names from the query result
+        while (my ($project_name) = $sth_trait->fetchrow_array) {
+            push @validated_projects, $project_name;
 
-    my $qc_cache_dir = $c->stash->{qualityControl_cache_dir};
-
-    copy($phenotype_file, $qc_cache_dir)
-    or die "could not copy $phenotype_file to $qc_cache_dir";
-
-    my $file = basename($phenotype_file);
-    $c->stash->{phenotype_file_name} = catfile($qc_cache_dir, $file);
-
-}
-
-
-sub create_qualityControl_dir {
-    my ($self, $c) = @_;
-
-    $c->controller('solGS::Files')->get_solgs_dirs($c);
-
-}
-
-
-sub pheno_qualityControl_output_files {
-    my ($self, $c) = @_;
-
-    my $pop_id = $c->stash->{pop_id};
-
-    $self->create_qualityControl_dir($c);
-    my $qc_cache_dir = $c->stash->{qualityControl_cache_dir};
-
-    my $file_cache  = Cache::File->new(cache_root => $qc_cache_dir);
-    $file_cache->purge();
-
-    my $key_table = 'qc_messages_table_' . $pop_id;
-    my $key_json  = 'qc_messages_json_' . $pop_id;
-    my $qc_messages_file      = $file_cache->get($key_table);
-    my $qc_messages_json_file = $file_cache->get($key_json);
-
-    unless ($qc_messages_file && $qc_messages_json_file )
-    {
-        $qc_messages_file = catfile($qc_cache_dir, "qc_messages_table_${pop_id}");
+        }
 
-        write_file($qc_messages_file);
-        $file_cache->set($key_table, $qc_messages_file, '30 days');
+        #print STDERR Dumper \@validated_projects;
+        my $list_projects = join(", ", @validated_projects);
 
-        $qc_messages_json_file = catfile($qc_cache_dir, "qc_messages_json_${pop_id}");
+        if (scalar(@validated_projects) > 0) {
+            my $project_names_str = join(", ", @validated_projects);
+            my $message = "Trait $trait is already validated data for trials: $list_projects";
+            $c->stash->{rest} = { message => $message };
+        } else {
+            $c->stash->{rest} = { data => \@data, trait => $trait};
+        }
+    };
 
-        write_file($qc_messages_json_file);
-        $file_cache->set($key_json, $qc_messages_json_file, '30 days');
+    if ($@) {
+        $c->response->body("Failed to search data: $@");
+            return;
     }
-
-    $c->stash->{qc_messages_table_file} = $qc_messages_file;
-    $c->stash->{qc_messages_json_file}  = $qc_messages_json_file;
 }
 
+sub data_restore :Path('/ajax/qualitycontrol/datarestore') Args(0) {
+    my $self = shift;
+    my $c = shift;
+    my $dbh = $c->dbc->dbh();
+    my $schema = $c->dbic_schema("Bio::Chado::Schema");
 
+    my $file = $c->req->param("file");
+    my $trait = $c->req->param("trait");
 
-sub pheno_qualityControl_analysis_output :Path('/phenotypic/qualityControl/analysis/output') Args(0) {
-    my ($self, $c) = @_;
-
-    my $pop_id = $c->req->param('population_id');
-    $c->stash->{pop_id} = $pop_id;
+    $file = basename($file);
 
-    $self->pheno_qualityControl_output_files($c);
-    my $qc_json_file = $c->stash->{qc_messages_json_file};
-    my $qc_table_file = $c->stash->{qc_messages_table_file};
-    my $ret->{status} = 'failed';
+    my $temppath = File::Spec->catfile($c->config->{basepath}, "static/documents/tempfiles/qualitycontrol/".$file);
 
-    if (!-s $qc_json_file)
-    {
-        $self->run_pheno_qualityControl_analysis($c);
-        $qc_json_file = $c->stash->{qc_messages_json_file};
-        $qc_table_file = $c->stash->{qc_messages_table_file};
+    my $F;
+    if (! open($F, "<", $temppath)) {
+    $c->stash->{rest} = { error => "Can't find data." };
+    return;
     }
 
-    if (-s $qc_json_file)
-    {
-    # $self->trait_acronyms($c);
-    # my $acronyms = $c->stash->{acronym};
+    my $header = <$F>;
+    chomp($header);
 
-    # $ret->{acronyms} = $acronyms;
-    $ret->{status}   = 'success';
+    my @keys = split("\t", $header);
 
-    my $data = $c->controller('solGS::Utils')->read_file_data($qc_table_file);
-    $ret->{data} = $data;
-    #$ret->{data}     = read_file($qc_json_file);
-    }
-
-    $ret = to_json($ret);
+    my @data = ();
 
-    $c->res->content_type('application/json');
-    $c->res->body($ret);
-
-}
-
-
-
-sub download_phenotypic_qualityControl : Path('/download/phenotypic/qualityControl/population') Args(1) {
-    my ($self, $c, $id) = @_;
-
-    $self->create_qualityControl_dir($c);
-    my $qc_dir = $c->stash->{qualityControl_cache_dir};
-    my $qc_file = catfile($qc_dir,  "qc_messages_table_${id}");
-
-    unless (!-e $qc_file || -s $qc_file <= 1)
-    {
-    my @qc_data;
-    my $count=1;
-
-    foreach my $row ( read_file($qc_file) )
-    {
-        if ($count==1) {  $row = 'Traits,' . $row;}
-        $row =~ s/NA//g;
-        $row = join(",", split(/\s/, $row));
-        $row .= "\n";
-
-        push @qc_data, [ $row ];
-        $count++;
+    while (<$F>) {
+        chomp;
+        my @fields = split "\t";
+        my %line = ();
+        
+        for (my $n = 0; $n < @keys; $n++) {
+            if (exists($fields[$n]) && defined($fields[$n])) {
+                $line{$keys[$n]} = $fields[$n];
+            }
+        }
+        if (defined $line{$trait} && $line{$trait} ne '') {
+            push @data, \%line;
+        }
     }
 
-    $c->res->content_type("text/plain");
-    $c->res->body(join "",  map{ $_->[0] } @qc_data);
+    my %unique_names;
+    foreach my $entry (@data) {
+        if (defined $entry->{'studyName'} && $entry->{'studyName'} ne '') {
+            $unique_names{$entry->{'studyName'}} = 1;
+        }
     }
-}
-
-
-sub temp_pheno_qc_output_file {
-    my ($self, $c) = @_;
-
-    my $pop_id = $c->stash->{pop_id};
-    $self->pheno_qualityControl_output_files($c);
-
-    my $files = join ("\t",
-              $c->stash->{qc_messages_table_file},
-              $c->stash->{qc_messages_json_file},
-    );
-
-    my $tmp_dir = $c->stash->{qualityControl_temp_dir};
-    my $name = "pheno_qc_output_files_${pop_id}";
-    my $tempfile =  $c->controller('solGS::Files')->create_tempfile($tmp_dir, $name);
-    write_file($tempfile, $files);
-
-    $c->stash->{temp_pheno_qc_output_file} = $tempfile;
 
+    # Format the unique project names for the SQL query
+    my $project_names = join(", ", map { "'$_'" } keys %unique_names);
+    
+    $c->stash->{rest} = { data => $project_names, trait => $trait};
 }
 
-
-sub temp_pheno_qc_input_file {
+sub store_outliers : Path('/ajax/qualitycontrol/storeoutliers') Args(0) {
     my ($self, $c) = @_;
+    my $sp_person_id = $c->user() ? $c->user->get_object()->get_sp_person_id() : undef;
+    my $operator = $c->user()->get_object()->get_first_name()." ".$c->user()->get_object()->get_last_name();
 
-    my $pop_id = $c->stash->{pop_id};
-
-    $c->controller("solGS::Files")->phenotype_file_name($c, $pop_id);
-    #$self->create_qualityControl_phenodata_file($c);
-
-    my $pheno_file = $c->stash->{phenotype_file_name};
-
-    $c->controller("solGS::Files")->formatted_phenotype_file($c);
-    my $formatted_pheno_file = $c->stash->{formatted_phenotype_file};
-
-    $c->controller("solGS::Files")->phenotype_metadata_file($c);
-    my $metadata_file = $c->stash->{phenotype_metadata_file};
-
-    my $files = join ("\t",
-              $pheno_file,
-              $formatted_pheno_file,
-              $metadata_file,
-              $c->req->referer,
-    );
-
-    my $tmp_dir = $c->stash->{qualityControl_temp_dir};
-    my $name = "pheno_qc_input_files_${pop_id}";
-    my $tempfile =  $c->controller('solGS::Files')->create_tempfile($tmp_dir, $name);
-    write_file($tempfile, $files);
-    $c->stash->{temp_pheno_qc_input_file} = $tempfile;
-
-}
-
-
-
-sub run_pheno_qualityControl_analysis {
-    my ($self, $c) = @_;
-
-    my $pop_id = $c->stash->{pop_id};
-
-    $self->temp_pheno_qc_input_file($c);
-    $self->temp_pheno_qc_output_file($c);
-
-    $c->stash->{qc_input_files}  = $c->stash->{temp_pheno_qc_input_file};
-    $c->stash->{qc_output_files} = $c->stash->{temp_pheno_qc_output_file};
-
-    $c->stash->{qualityControl_type} = "pheno-qualityControl";
-
-    $c->stash->{qualityControl_script} = "R/qualityControl/qc_rscript.R";
-
-    $self->run_qualityControl_analysis($c);
-
-    $self->trait_acronyms($c);
-}
-
-
-sub run_qualityControl_analysis {
-    my ($self, $c) = @_;
-
-    my $pop_id = $c->stash->{pop_id};
-    my $qc_type = $c->stash->{qualityControl_type};
-
-    $self->qc_pheno_query_jobs_file($c);
-    my $queries_file = $c->stash->{qc_pheno_query_jobs_file};
-
-    $self->qc_pheno_r_jobs_file($c);
-    my $r_jobs_file = $c->stash->{qc_pheno_r_jobs_file};
-
-    $c->stash->{prerequisite_jobs} = $queries_file if $queries_file;
-    $c->stash->{dependent_jobs} = $r_jobs_file;
-
-    $c->controller('solGS::solGS')->run_async($c);
-
-}
+    my $schema = $c->dbic_schema("Bio::Chado::Schema", undef, $sp_person_id);
 
+    my @user_roles = $c->user()->roles;
+    my $curator = (grep { $_ eq 'curator' || $_ eq 'breeder' } @user_roles) ? 1 : 0;
 
-sub qc_pheno_r_jobs {
-    my ($self, $c) = @_;
+    my $response_data = {
+    is_curator => $curator ? 1 : 0,  # 1 if curator, 0 otherwise
+    };
 
-    my $pop_id = $c->stash->{trial_id} || $c->stash->{pop_id};
 
-    my $input_file = $c->stash->{qc_input_files};
-    my $output_file = $c->stash->{qc_output_files};
+    # Retrieve and decode the outliers from the request
+    my $outliers_string = $c->req->param('outliers');
+    
+    # Now proceed to decode JSON
+    my $outliers_data = decode_json($outliers_string);
 
-    my $qc_type = $c->stash->{qualityControl_type};
+    my %trait_ids;
+    my %study_names;
+    my $trait;
 
-    $c->stash->{input_files}  = $input_file;
-    $c->stash->{output_files} = $output_file;
-    $c->stash->{r_temp_file}  = "${qc_type}-${pop_id}";
-    $c->stash->{r_script}     = $c->stash->{qualityControl_script};
+    my $othertraits_json = $c->req->param('othertraits');  
+    my $othertraits = decode_json($othertraits_json);
 
-    $c->stash->{analysis_tempfiles_dir} = $c->stash->{qualityControl_temp_dir};
+    # Remove duplicates using a hash
+    my %unique_traits = map { $_ => 1 } @$othertraits;
+    my @unique_othertraits = keys %unique_traits;
 
-    $c->controller('solGS::AsyncJob')->get_cluster_r_job_args($c);
-    my $jobs  = $c->stash->{cluster_r_job_args};
+    # @unique_othertraits = map { s/\|.*//r } @unique_othertraits;
+    # print STDERR Dumper \@unique_othertraits;
 
-    if (reftype $jobs ne 'ARRAY')
-    {
-    $jobs = [$jobs];
+    foreach my $entry (@$outliers_data) { 
+        $trait = $entry->{trait};  # Directly use the trait from the entry
+        my $study_name = $entry->{studyName};
+        $study_names{$study_name} = 1 if defined $study_name;
     }
-
-    $c->stash->{qc_pheno_r_jobs} = $jobs;
-
-}
-
-
-sub qc_pheno_r_jobs_file {
-    my ($self, $c) = @_;
-
-    $self->qc_pheno_r_jobs($c);
-    my $jobs = $c->stash->{qc_pheno_r_jobs};
-
-    my $temp_dir = $c->stash->{qualityControl_temp_dir};
-    my $jobs_file =  $c->controller('solGS::Files')->create_tempfile($temp_dir, 'qc-r-jobs-file');
-
-    nstore $jobs, $jobs_file
-    or croak "qualityControl r jobs : $! serializing qualityControl r jobs to $jobs_file";
-
-    $c->stash->{qc_pheno_r_jobs_file} = $jobs_file;
-
-}
-
-sub qc_pheno_query_jobs {
-    my ($self, $c) = @_;
-
-    my $trial_id = $c->stash->{pop_id} || $c->stash->{trial_id};
-
-    $c->controller('solGS::AsyncJob')->get_trials_phenotype_query_jobs_args($c, [$trial_id]);
-    my $jobs = $c->stash->{trials_phenotype_query_jobs_args};
-
-    if (reftype $jobs ne 'ARRAY')
-    {
-	$jobs = [$jobs];
+    
+    my @alltraits = ($trait, @unique_othertraits);
+    foreach my $sel_trait (@alltraits) {
+        $trait_ids{$sel_trait} = SGN::Model::Cvterm->get_cvterm_row_from_trait_name($schema, $sel_trait)->cvterm_id;
     }
-
-    $c->stash->{qc_pheno_query_jobs} = $jobs;
-
-}
-
-
-sub qc_pheno_query_jobs_file {
-    my ($self, $c) = @_;
-
-    $self->qc_pheno_query_jobs($c);
-    my $jobs = $c->stash->{qc_pheno_query_jobs};
-
-    my $jobs_file;
-
-    if ($jobs->[0])
-    {
-	my $temp_dir = $c->stash->{qualityControl_temp_dir};
-	$jobs_file =  $c->controller('solGS::Files')->create_tempfile($temp_dir, 'pheno-qc-query-jobs-file');
-
-	nstore $jobs, $jobs_file
-	    or croak "qualityControl pheno query jobs : $! serializing qualityControl phenoquery jobs to $jobs_file";
+    
+
+    $trait =~ s/\|.*//;
+    my $trait_operator = $trait."|".$operator;
+
+    # Convert unique study names to a comma-separated list in SQL format
+    my @unique_study_names = keys %study_names;
+    return $c->response->body('No unique study names found.') unless @unique_study_names;
+
+    my $study_names_sql = join(", ", map { $schema->storage->dbh->quote($_) } @unique_study_names);  # Quote each name
+    
+    # Add validated traits to projectprop
+    my $trial_sql = qq{
+        INSERT INTO projectprop (project_id, type_id, value, rank)
+        SELECT 
+            p.project_id,
+            (SELECT cvterm_id FROM cvterm WHERE name = 'validated_phenotype'),
+            '$trait_operator',
+            COALESCE(MAX(pp.rank), 0) + 1  -- Increment rank
+        FROM project p
+        LEFT JOIN projectprop pp
+            ON p.project_id = pp.project_id
+            AND pp.type_id = (SELECT cvterm_id FROM cvterm WHERE name = 'validated_phenotype')
+        WHERE p.name in ($study_names_sql)
+        GROUP BY p.project_id;
+    };
+
+    my $experiment_type = SGN::Model::Cvterm->get_cvterm_row($schema, 'phenotyping_experiment', 'experiment_type')->cvterm_id();
+
+    # Extract plot names from the outliers data
+    my @plot_names = map { $_->{plotName} } @$outliers_data;
+    my @plot_values = map { $_->{value} } @$outliers_data;
+
+    my %seen;
+    @plot_names = grep { !$seen{$_}++ } @plot_names;
+
+    my @unique_trait_ids = grep { !$seen{$_}++ } values %trait_ids;
+    my $trait_ids_sql = join(", ", @unique_trait_ids);
+
+    
+    if (@plot_names && %trait_ids) {
+        # print STDERR Dumper \@plot_names;
+        # Convert plot names and traits into comma-separated lists for SQL
+        my $plot_names_sql = join(", ", map { $schema->storage->dbh()->quote($_) } @plot_names);
+
+        # Build the SQL query
+        my $outlier_data_sql = "
+            INSERT INTO phenotypeprop (phenotype_id, type_id, value)
+            SELECT phenotype.phenotype_id, 
+                   (SELECT cvterm_id FROM cvterm WHERE name = 'phenotype_outlier'), 
+                   phenotype.value 
+            FROM phenotype
+            JOIN nd_experiment_phenotype ON nd_experiment_phenotype.phenotype_id = phenotype.phenotype_id 
+            JOIN nd_experiment_stock ON nd_experiment_stock.nd_experiment_id = nd_experiment_phenotype.nd_experiment_id 
+            WHERE nd_experiment_stock.stock_id IN (
+                SELECT stock.stock_id FROM stock WHERE uniquename IN ($plot_names_sql)
+            )
+            AND nd_experiment_stock.type_id = $experiment_type
+            AND phenotype.observable_id IN ($trait_ids_sql)
+            AND NOT EXISTS (
+                SELECT 1 FROM phenotypeprop 
+                WHERE phenotypeprop.phenotype_id = phenotype.phenotype_id
+                AND phenotypeprop.type_id = (SELECT cvterm_id FROM cvterm WHERE name = 'phenotype_outlier')
+            );";
+
+        if($curator == 1){
+            # Execute the SQL query
+            eval {
+                my $sth_trial = $schema->storage->dbh->prepare($trial_sql);
+                $sth_trial->execute();
+
+                my $sth_outliers = $schema->storage->dbh->prepare($outlier_data_sql);
+                $sth_outliers->execute();
+                
+                $c->stash->{rest} = $response_data;
+            };
+        } else {
+            $c->stash->{rest} = $response_data;
+            
+        }
+    } else {
+        $c->response->body('No plot names or traits found.');
     }
 
-    $c->stash->{qc_pheno_query_jobs_file} = $jobs_file;
-
+    
+    ## celaning tempfiles
+    rmtree(File::Spec->catfile($c->config->{basepath}, "static/documents/tempfiles/qualitycontrol"));
 }
 
+sub restore_outliers : Path('/ajax/qualitycontrol/restoreoutliers') Args(0) {
 
-sub begin : Private {
     my ($self, $c) = @_;
+    my $dbh = $c->dbc->dbh();
+    my $sp_person_id = $c->user() ? $c->user->get_object()->get_sp_person_id() : undef;
+    my $schema = $c->dbic_schema("Bio::Chado::Schema", undef, $sp_person_id);
+    my @user_roles = $c->user()->roles;
+    
+    my $curator = (grep { $_ eq 'curator' } @user_roles) ? 'curator' : undef;
+    
+
+    # Retrieve and decode the outliers from the request
+    my $outliers_string = $c->req->param('outliers');
+    my $outlier_trials;
+    $outlier_trials = decode_json($outliers_string);
+    
+    # getting trait name
+    my $trait = $c->req->param('trait');
+    $trait =~ s/\|.*//;
+
+    my $trait_like = $trait . '%';
+
+    my $response_data = {
+    is_curator => $curator ? 1 : 0,  # 1 if curator, 0 otherwise
+    };
+
+    my $trial_clean_sql = qq{
+        DELETE FROM projectprop
+        WHERE projectprop.project_id IN (
+            SELECT projectprop.project_id
+            FROM projectprop
+            JOIN project ON project.project_id = projectprop.project_id
+            WHERE project.name IN ($outlier_trials)
+        )
+        AND projectprop.value LIKE '$trait_like'
+        AND projectprop.type_id = (
+            SELECT cvterm_id FROM cvterm WHERE name = 'validated_phenotype'
+        );
+    };
+
+    my $outliers_clean_sql = qq{
+        DELETE FROM phenotypeprop
+        WHERE phenotypeprop.phenotype_id IN (
+            SELECT phenotypeprop.phenotype_id
+            FROM phenotypeprop
+            JOIN phenotype ph ON phenotypeprop.phenotype_id = ph.phenotype_id
+            JOIN nd_experiment_phenotype nep ON nep.phenotype_id = phenotypeprop.phenotype_id
+            JOIN nd_experiment_project nes ON nes.nd_experiment_id = nep.nd_experiment_id
+            JOIN project pr ON pr.project_id = nes.project_id
+            WHERE ph.observable_id = (
+                SELECT cvterm_id FROM cvterm WHERE cvterm.name like '$trait_like'
+            )
+            AND pr.name IN ($outlier_trials)
+        );
+    };
+    
+    
+
+    # Execute the SQL query
+    if ($curator eq 'curator'){
+        eval {
+            my $sth_trial = $dbh->prepare($trial_clean_sql);
+            $sth_trial->execute();
+
+            my $sth_clean = $dbh->prepare($outliers_clean_sql);
+            $sth_clean->execute();
+        };
+
+        if ($@) {
+            $c->response->body("Failed to store data: $@");
+            return;
+        } else {
+            $c->stash->{rest} = $response_data;
+        }
+    } else {
+        $c->stash->{rest} = $response_data;
+    }
 
-    $c->controller('solGS::Files')->get_solgs_dirs($c);
+    ## celaning tempfiles
+    rmtree(File::Spec->catfile($c->config->{basepath}, "static/documents/tempfiles/qualitycontrol"));
 
 }
 
 
-
-####
 1;
-####
diff --git a/lib/SGN/Controller/AJAX/Stability.pm b/lib/SGN/Controller/AJAX/Stability.pm
index a57b00c1a9..94ebd5fae1 100644
--- a/lib/SGN/Controller/AJAX/Stability.pm
+++ b/lib/SGN/Controller/AJAX/Stability.pm
@@ -147,7 +147,7 @@ sub generate_results: Path('/ajax/stability/generate_results') : {
     #my $temppath = $stability_tmp_output . "/" . $tempfile;
     my $temppath =  $tempfile;
 
-    my $ds = CXGN::Dataset::File->new(people_schema => $people_schema, schema => $schema, sp_dataset_id => $dataset_id, exclude_dataset_outliers => $exclude_outliers, file_name => $temppath, quotes => 0);
+    my $ds = CXGN::Dataset::File->new(people_schema => $people_schema, schema => $schema, sp_dataset_id => $dataset_id, exclude_dataset_outliers => $exclude_outliers, exclude_phenotype_outlier => $exclude_outliers,file_name => $temppath, quotes => 0);
 
     my $phenotype_data_ref = $ds->retrieve_phenotypes($pheno_filepath);
 
diff --git a/lib/SGN/Controller/AJAX/ValidatedTrials.pm b/lib/SGN/Controller/AJAX/ValidatedTrials.pm
new file mode 100644
index 0000000000..dfb52cba61
--- /dev/null
+++ b/lib/SGN/Controller/AJAX/ValidatedTrials.pm
@@ -0,0 +1,210 @@
+
+package SGN::Controller::AJAX::ValidatedTrials;
+
+use Moose;
+
+use Data::Dumper;
+use File::Slurp;
+use File::Spec qw | catfile |;
+use File::Path qw(rmtree);
+use JSON::Any;
+use File::Basename qw | basename |;
+use DateTime;
+use Bio::Chado::Schema;
+use CXGN::Dataset::File;
+use CXGN::Phenotypes::File;
+use CXGN::Phenotypes::PhenotypeMatrix;
+use SGN::Controller::AJAX::Dataset;
+use CXGN::BreedersToolbox::Projects;
+use JSON;
+
+
+BEGIN { extends 'Catalyst::Controller::REST' };
+
+__PACKAGE__->config(
+    default => 'application/json',
+    stash_key => 'rest',
+    map => { 'application/json' => 'JSON' },
+   );
+
+
+
+sub grab_data :Path('/ajax/validatedtrials/grabdata') Args(0) {
+    my $self = shift;
+    my $c = shift;
+    my $dbh = $c->dbc->dbh();
+    my $schema = $c->dbic_schema("Bio::Chado::Schema");
+
+    
+
+    my $trials_sql = qq{
+        SELECT project."name", 
+            nd_geolocation.description as location,
+            validated_prop.value AS trait_name
+        FROM project
+        JOIN projectprop AS validated_prop ON validated_prop.project_id = project.project_id
+        JOIN projectprop AS location_prop ON location_prop.project_id = project.project_id
+        JOIN nd_geolocation ON nd_geolocation.nd_geolocation_id = location_prop.value::integer
+        WHERE validated_prop.type_id = (SELECT cvterm_id FROM cvterm WHERE name = 'validated_phenotype')
+          AND location_prop.type_id = (SELECT cvterm_id FROM cvterm WHERE name = 'project location')
+         GROUP BY project."name",location, trait_name;
+    };
+
+    my @validated_projects;
+    eval {
+        # Prepare and execute the query
+        my $sth_trial = $dbh->prepare($trials_sql);
+        $sth_trial->execute();
+
+        # Collect project names from the query result
+        while (my ($project_name, $project_location, $validated_trait) = $sth_trial->fetchrow_array) {
+            # Split the validated_trait into two parts using '|' as the separator
+            my ($trait, $username) = split(/\|/, $validated_trait, 2);
+
+            # Store each row's data in a hash reference
+            my $project_data = {
+                name => $project_name,
+                project_location => $project_location,
+                validated_trait => $trait,  # First part
+                username => $username,     # Second part
+            };
+
+            # Push the hash reference into the array
+            push @validated_projects, $project_data;
+        }
+        
+        # print STDERR Dumper \@validated_projects;
+
+    };
+
+    my $json = JSON->new;
+    $c->stash->{rest} = { data => \@validated_projects };
+
+    # Explicitly encode the response as JSON
+    my $encoded_response = $json->encode({ data => \@validated_projects });
+    $c->response->body($encoded_response);
+
+    if ($@) {
+        $c->response->body("Failed to search data: $@");
+            return;
+    }
+}
+
+sub get_coordinate :Path('/ajax/validatedtrials/getcoordinates') Args(0) {
+    
+    my ($self, $c) = @_;
+    
+    my $sp_person_id = $c->user() ? $c->user->get_object()->get_sp_person_id() : undef;
+    my $schema = $c->dbic_schema("Bio::Chado::Schema", undef, $sp_person_id);
+    my $dbh = $c->dbc->dbh();
+    
+
+    # Parse the input JSON to get the list of location names
+    my $locations_json = $c->req->param('locNames');
+    my $location_names = decode_json($locations_json);
+
+    # Escape the location names for SQL query
+    my $placeholders = join(", ", ("?") x @$location_names);
+
+    # Prepare and execute the SQL query
+    my $sql = "
+        SELECT DISTINCT p.name, p.project_id, ng.latitude, ng.longitude
+        FROM project p
+        JOIN nd_experiment_project nep ON nep.project_id = p.project_id
+        JOIN nd_experiment ne ON ne.nd_experiment_id = nep.nd_experiment_id
+        JOIN nd_geolocation ng ON ng.nd_geolocation_id = ne.nd_geolocation_id
+        WHERE p.name IN ($placeholders)
+    ";
+    
+    
+    eval{
+        my $sth = $dbh->prepare($sql);
+        $sth->execute(@{$location_names});
+        
+        my @locations_with_coordinates;
+        while (my ($name, $project_id, $latitude, $longitude) = $sth->fetchrow_array) {
+            push @locations_with_coordinates, { name => $name, trial_id => $project_id, latitude => $latitude, longitude => $longitude };
+        }
+        # Return the results as JSON
+        $c->res->content_type('application/json');
+        $c->res->body(encode_json(\@locations_with_coordinates));
+    };
+
+    if ($@) {
+        $c->res->status(500);
+        $c->res->body(encode_json({ error => "Database error: $_" }));
+    };
+
+}
+
+sub get_phenotype :Path('/ajax/validatedtrials/getphenotype') Args(0){
+
+    my ($self, $c) = @_;
+    
+    my $sp_person_id = $c->user() ? $c->user->get_object()->get_sp_person_id() : undef;
+    my $schema = $c->dbic_schema("Bio::Chado::Schema", undef, $sp_person_id);
+    my $dbh = $c->dbc->dbh();
+
+    # Parse the input JSON to get the list of trial and trait pairs
+    my $projects_json = $c->req->param('projectTrait');
+    my $projects_names = decode_json($projects_json);
+
+    # Array to hold final results
+    my @data;
+
+    foreach my $project (@$projects_names) {
+        my $trial_name = $project->{name};             
+        my $trait_name = $project->{validated_trait};
+
+        # Skip if either trial or trait is missing
+        next unless $trial_name && $trait_name;
+
+        # Fetch phenotype data for this trial–trait pair, excluding outliers
+        my $sql_phenotypes = "
+            select p.name as location_name, s.uniquename as plot_name, s2.uniquename as accession, cvterm.name as trait, phenotype.value 
+            from phenotype 
+            join nd_experiment_phenotype nep ON nep.phenotype_id = phenotype.phenotype_id 
+            join nd_experiment_project nep2 on nep2.nd_experiment_id = nep.nd_experiment_id
+            join nd_experiment_stock nes on nes.nd_experiment_id = nep.nd_experiment_id
+            join phenotype p2 ON p2.phenotype_id = nep.phenotype_id 
+            join project p on p.project_id = nep2.project_id
+            join cvterm on p2.cvalue_id = cvterm.cvterm_id 
+            join stock s on s.stock_id = nes.stock_id
+            join stock_relationship sr on sr.subject_id = nes.stock_id
+            join stock s2 on s2.stock_id = sr.object_id 
+            where p.name = ?
+            and cvterm.name = ?
+            and phenotype.phenotype_id not in ( select phenotype_id from phenotypeprop p3 WHERE p3.type_id = ( select cvterm_id from cvterm where name = 'phenotype_outlier'));
+        ";
+
+        eval {
+            my $sth = $dbh->prepare($sql_phenotypes);
+            $sth->execute($trial_name, $trait_name);
+
+            while (my ($location, $plot, $accession, $trait, $value) = $sth->fetchrow_array) {
+                push @data, {
+                    trial => $location,
+                    plot => $plot,
+                    accession => $accession,
+                    trait => $trait,
+                    value => $value,
+                };
+            }
+        };
+
+        # Handle errors
+        if ($@) {
+            warn "Error fetching phenotype data for trial '$trial_name' and trait '$trait_name': $@";
+        }
+    }
+
+    # Return the combined results as JSON
+    $c->res->content_type('application/json');
+    $c->res->body(encode_json(\@data));
+
+    # Debugging: Print results
+    # print Dumper \@data;
+}
+
+
+1;
diff --git a/lib/SGN/Controller/QualityControl.pm b/lib/SGN/Controller/QualityControl.pm
new file mode 100755
index 0000000000..95c8c96136
--- /dev/null
+++ b/lib/SGN/Controller/QualityControl.pm
@@ -0,0 +1,22 @@
+
+package SGN::Controller::QualityControl;
+
+use Moose;
+use URI::FromHash qw | uri |;
+
+BEGIN { extends 'Catalyst::Controller' };
+
+
+sub quality_control_index :Path('/tools/qualitycontrol') Args(0) { 
+
+    my $self = shift;
+    my $c = shift;
+
+    if (!$c->user()) { 
+	$c->res->redirect( uri( path => '/user/login', query => { goto_url => $c->req->uri->path_query } ) );
+    }
+    
+    $c->stash->{template} = '/tools/qualityControl/dataset_quality_control.mas';
+}
+
+1;
diff --git a/lib/SGN/Controller/ValidatedTrials.pm b/lib/SGN/Controller/ValidatedTrials.pm
new file mode 100755
index 0000000000..516d520615
--- /dev/null
+++ b/lib/SGN/Controller/ValidatedTrials.pm
@@ -0,0 +1,22 @@
+
+package SGN::Controller::ValidatedTrials;
+
+use Moose;
+use URI::FromHash qw | uri |;
+
+BEGIN { extends 'Catalyst::Controller' };
+
+
+sub quality_control_index :Path('/tools/validatedtrials') Args(0) { 
+
+    my $self = shift;
+    my $c = shift;
+
+    if (!$c->user()) { 
+	$c->res->redirect( uri( path => '/user/login', query => { goto_url => $c->req->uri->path_query } ) );
+    }
+    
+    $c->stash->{template} = '/tools/qualityControl/validated_trials.mas';
+}
+
+1;
diff --git a/mason/tools/heritability/index.mas b/mason/tools/heritability/index.mas
index 5255198041..4f1c60702f 100644
--- a/mason/tools/heritability/index.mas
+++ b/mason/tools/heritability/index.mas
@@ -8,8 +8,7 @@
 
 <%perl>
   use JSON::Any;
-
-
+  
 </%perl>
 
 
@@ -129,6 +128,17 @@
 <script>
 
 
+var require_login = "<%  $c->get_conf('brapi_require_login') %>";
+if (require_login === '1'){
+    auth_token = "<%  CXGN::Login->new($c->dbc->dbh)->get_login_cookie() %>";
+    if (!auth_token){ alert("Login required to display heritability"); }
+}
+
+var check_outliers = "<% $c->get_conf('exclude_phenotype_outliers') || 0 %>";
+
+if (parseInt(check_outliers) === 1) {
+    document.getElementById('dataset_trait_outliers').checked = true;
+}
 
 jQuery(document).ready(function() {
   if (isLoggedIn()) {
@@ -143,13 +153,14 @@ jQuery(document).ready(function() {
     $('#trait_histogram_plot').html('');
     $('#heritability_output').empty();
   });
-  
+
   jQuery('#selectDataset').click(function() {
     var dataset_id = get_dataset_id();    
     if (!dataset_id) {
       return;
     }
-    var dataset_trait_outliers = $('#dataset_trait_outliers').is(':checked') ? 1 : 0;
+
+    dataset_trait_outliers = $('#dataset_trait_outliers').is(':checked') ? 1 : 0;
     document.getElementById("preview_trait_histogram_btn").disabled = true;  
     document.getElementById("loading-spinner").style.visibility = 'visible'; 
     $.ajax({
diff --git a/mason/tools/mixedmodels.mas b/mason/tools/mixedmodels.mas
index 6804059524..f9f5802f24 100644
--- a/mason/tools/mixedmodels.mas
+++ b/mason/tools/mixedmodels.mas
@@ -85,6 +85,9 @@
 		</div>
 	      </div>
 	      <br />
+        <input type="checkbox" id="dataset_trait_outliers" />
+        <label>Use validated trials &nbsp; </label>          
+        <br>
 	      <br />
 
 </&>
@@ -242,6 +245,12 @@
 
 <script>
 
+var check_outliers = "<% $c->get_conf('exclude_phenotype_outliers') || 0 %>";
+
+if (parseInt(check_outliers) === 1) {
+    document.getElementById('dataset_trait_outliers').checked = true;
+}
+
 $(document).ready( function() {
 var mixedmodels = window.jsMod['mixedmodels'].init("mixedmodels");
 });
diff --git a/mason/tools/qualityControl/dataset_quality_control.mas b/mason/tools/qualityControl/dataset_quality_control.mas
new file mode 100755
index 0000000000..cd86d4b574
--- /dev/null
+++ b/mason/tools/qualityControl/dataset_quality_control.mas
@@ -0,0 +1,235 @@
+<%args>
+
+</%args>
+
+<& /util/import_javascript.mas, classes => ['jquery', 'CXGN.BreedersToolbox.HTMLSelect'], entries => ['qualitycontrol' ] &>
+
+<script src="https://cdn.jsdelivr.net/npm/vega@3"></script>
+<script src="https://cdn.jsdelivr.net/npm/vega-lite@2"></script>
+<script src="https://cdn.jsdelivr.net/npm/vega-embed@3"></script>
+
+
+<& /page/page_title.mas, title=>"Quality Control" &>
+
+
+<div id="qualitycontrol_tool">
+</div>
+
+
+<style>
+  .factor {
+  z-index:4;
+  border-style:solid;
+  border-radius:8px;
+  width:200px;
+  height:100;
+  border-color:#337ab7;
+  background-color:#337ab7;
+  color:white;
+  margin:4px
+  }
+  .factor_panel {
+  min-height:100px;
+  height:auto;
+  margin-top:0px;
+  border-style:dotted;
+  border-width:5px;
+  color:grey;
+  background-color:lightyellow;
+  }
+  .factor_interaction_panel {
+  border-style:dotted;
+  border-width:0px;
+  margin-top:20px;
+  height:auto;
+  z-index:1;
+  }
+  .model_bg {
+  margin-left:30px;
+  margin-right:30px;
+  background-color:#DDEEEE;
+  min-height:80px;
+  padding-top:10px;
+  padding-left:10px;
+  padding-bottom:10px;
+  border-radius:8px;
+  }
+
+#outliers_range .ui-slider-range { background: #5cb85c; }
+#outliers_range .ui-slider-handle { border-color: #d9534f; }                
+#outliers_range { background: #d9534f; margin-top: 0.7em;}       
+#custom-handle {
+    width: 3em;
+    height: 1.6em;
+    top: 50%;
+    margin-top: -.8em;
+    text-align: center;
+    line-height: 1.6em;
+}           
+
+</style>
+
+<div id="qualitycontrol_tool">
+</div>
+
+
+<div class="container">
+  <div class="row">
+    <div class="col-md-12">
+      <div class="container-fluid">
+        <&| /util/workflow.mas, id=> "quality_control_analysis_workflow" &>
+          <&| /util/workflow.mas:step, title=> "Choose Dataset" &>
+            <& /page/page_title.mas, title=>"Choose the dataset for QC" &>
+        <span style="width:240px" id="qc_dataset_select">
+        </span>
+        <div>
+          <div style="float:right">
+            <button class="btn btn-main" id="qc_analysis_prepare_button"   onclick="Workflow.complete(this);">Choose Dataset and continue</button>
+          </div>
+        </div>
+        <br />
+        <br />
+
+        </&>
+
+
+        <&| /util/workflow.mas:step, title=> "Select Trait" &>
+        <& /page/page_title.mas, title=>"Select a Trait for QC" &>
+
+        <!-- Existing checkboxes (dynamic options) -->
+        <div id="selected_variable" style="margin-bottom:50px">
+          <label for="trait_select">Select Trait:</label>
+          <select id="trait_select" name="trait_select" class="form-control">
+              <option disabled selected value>Select a trait</option>
+          </select>
+        </div>
+
+        <div id="trait_boxplot">
+        <br>
+        <br>
+        </div>
+
+        <div class="col-md-12 well" style="margin-top: 10px;">  
+            <h3>Outliers Range</h3>   
+            <div class="col-md-8">
+                <div id="outliers_range">
+                    <div id="custom-handle" class="ui-slider-handle"></div>
+                </div>
+            </div>
+        </div>
+
+        <hr style="border: 1px solid gray; margin: 20px 0;">
+        <div class="col-md-12 collapsible">
+            <div class="content">
+                <h4><b>Selecting this box, it will set fixed minimum and maximum for all locations.</b></h4>
+                <br>
+                <div style="display: flex; align-items: center; gap: 10px; margin-top: 10px;">
+                    <label for="min-limit">Minimum limit:</label>
+                    <input type="number" id="min-limit" name="min-limit" placeholder="Enter minimum" class="form-control" style="width: auto;">
+
+                    <label for="max-limit">Maximum limit:</label>
+                    <input type="number" id="max-limit" name="max-limit" placeholder="Enter maximum" class="form-control" style="width: auto;">
+                </div>
+                <br>
+                <br>
+                <div style="display: flex; align-items: center; gap: 10px;">
+                    <button id="fixed-min-max" style="margin-right: 5px;">
+                        Select Fixed Min and Max
+                    </button>
+                </div>
+            </div>
+            <br>
+            <br>
+        </div>
+        <hr style="border: 1px solid gray; margin: 20px 0;">
+
+        <div id="outlier_table_container">
+            <h3>Raw Data Available</h3>
+            <table id="outlier_table" class="table table-bordered table-striped">
+                <thead>
+                    <tr>
+                        <th>Location ID</th>
+                        <th>Location Name</th>
+                        <th>Trial Name</th>
+                        <th>Min</th>
+                        <th>Max</th>
+                        <th>Mean</th>
+                        <th>SD</th>
+                        <th>CV</th>
+                    </tr>
+                </thead>
+                <tbody></tbody>
+            </table>
+        </div>
+
+        <div id="cleaned_table_container">
+        <h3>Data After Filtering</h3>
+        <table id="clean_table" class="table table-bordered table-striped">
+            <thead>
+                <tr>
+                    <th>Location ID</th>
+                    <th>Location Name</th>
+                    <th>Trial Name</th>
+                    <th>Min</th>
+                    <th>Max</th>
+                    <th>Mean</th>
+                    <th>SD</th>
+                    <th>CV</th>
+                </tr>
+            </thead>
+            <tbody></tbody>
+        </table>
+        <br>
+        </div>
+        <div style="float:right">
+            <button class="btn btn-main" id="qc_choose_variable"  onclick="Workflow.complete(this);">Next step</button>
+        </div>
+      </&>
+
+      <&| /util/workflow.mas:step, title=> "Other Traits as Outlier" &>
+        <& /page/page_title.mas, title=>"Set Plot as Outlier for Other Traits" &>
+
+      <div style="text-align: center;">
+          <p>This is an option to set selected plots as outliers for other traits as well.</p>
+          <p>Clicking on <b>'Select Other Traits'</b> you will see available traits in your dataset.</p>
+          <p>If you want to ignore this step, please click on <b>'Next step'</b> button.</p>
+          <button id="select_traits_button">Select Other Traits</button>
+          <div id="other_traits" style="margin-top: 20px; margin-bottom: 50px;">
+              <!-- Dynamically populated checkboxes will appear here -->
+          </div>
+          <br>
+      </div>
+      <div style="float:right">
+          <button class="btn btn-main" id="qc_other_traits"  onclick="Workflow.complete(this);">Next step</button>
+      </div>
+
+      </&>
+
+      <&| /util/workflow.mas:step, title=> "Save Outliers" &>
+        <& /page/page_title.mas, title=>"Save Outliers" &>
+      <div>
+        <div style="text-align: center;">
+          <p>This is the validation process. Trials cleaned of outliers can be used in downstream analysis.</p>
+          <p>To validate a dataset you will need privilieges as <b>CURATOR</b> or <b>BREEDER</b>.</p>
+          <p>Only <b>CURATORS</b> are allowed to restore the dataset to original values.</p>
+          <button class="btn btn-main" id="restore_outliers_button"   onclick="Workflow.complete(this);">Restore</button>
+          <button class="btn btn-main" id="store_outliers_button"   onclick="Workflow.complete(this);">Validate</button>
+        </div>
+      </&>
+        <div id="tempfile" style="display:none"></div>
+      </div>
+  </div>
+</div>
+
+
+</&>
+
+
+<script>
+
+$(document).ready( function() {
+var qualitycontrol = window.jsMod['qualitycontrol'].init("qualitycontrol");
+});
+
+</script>
+
diff --git a/mason/tools/qualityControl/validated_trials.mas b/mason/tools/qualityControl/validated_trials.mas
new file mode 100644
index 0000000000..eb223028f3
--- /dev/null
+++ b/mason/tools/qualityControl/validated_trials.mas
@@ -0,0 +1,987 @@
+<%args>
+
+</%args>
+
+<& /util/import_javascript.mas, classes => ['jquery', 'CXGN.Login','CXGN.BreedersToolbox.HTMLSelect'], entries => ['validatedtrials' ] &>
+
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<link rel="stylesheet" href="https://unpkg.com/leaflet@1.7.1/dist/leaflet.css" />
+<script src="https://cdn.jsdelivr.net/npm/vega@4"></script>
+<script src="https://cdn.jsdelivr.net/npm/vega-lite@2"></script>
+<script src="https://cdn.jsdelivr.net/npm/vega-embed@3"></script>
+<script src="https://unpkg.com/leaflet@1.7.1/dist/leaflet.js"></script>
+<script src="https://d3js.org/d3.v7.min.js"></script>
+
+
+
+
+
+<& /page/page_title.mas, title=>"Validated Trials" &>
+
+<p>This table presents all trials that have been thoroughly filtered and validated through the Quality Control Tool.</p>
+<br>
+<div>
+    <input type="text" id="searchBox" placeholder="Search tool..." onkeyup="filterTable()">
+    <br>
+</div>
+<div id="validated_trials_tool">
+  <div>
+    <br>
+    <table id="projectDataTable" class="table table-bordered table-striped">
+        <thead>
+            <tr>
+                <th>Select</th> 
+                <th>Project Name</th>
+                <th>Project Location</th>
+                <th>Trait Name</th>
+                <th>Validated By</th>
+            </tr>
+        </thead>
+        <tbody>
+            <!-- Rows will be dynamically added here -->
+        </tbody>
+    </table>
+</div>
+<div id="paginationControls">
+    <button id="prevPageBtn" onclick="changePage(-1)">Previous</button>
+    <span id="currentPageLabel">Page 1</span>
+    <button id="nextPageBtn" onclick="changePage(1)">Next</button>
+</div>
+
+<!-- Items per page control -->
+<div>
+    <label for="itemsPerPage">Items per page:</label>
+    <select id="itemsPerPage" onchange="setItemsPerPage()">
+        <option value="5">5</option>
+        <option value="10" selected>10</option>
+        <option value="20">20</option>
+        <option value="50">50</option>
+        <option value="100">100</option>
+    </select>
+</div>
+
+<div id="location-checkboxes"></div>
+</div>
+<div id="map"></div>
+
+<br>
+<br>
+
+<&| /page/info_section.mas, title=>"Statistcs", collapsible=>1, collapsed=>1 &>
+
+    <button id="calculate_statistics">Calculate Statistics</button>
+    <br>
+    <div>
+        <br>
+        <table id="statTable" class="table table-bordered table-striped">
+            <thead>
+                <tr>
+                    <th>Accession</th>
+                    <th>Trials</th>
+                    <th>Observations</th> 
+                    <th>Trait</th>
+                    <th>Average</th>
+                    <th>SD</th>
+                    <th>Min</th>
+                    <th>Max</th>
+                </tr>
+            </thead>
+            <tbody>
+                <!-- Rows will be dynamically added here -->
+            </tbody>
+        </table>
+    </div>
+    <button id="downloadCsvButton">Download CSV</button>
+
+
+</&>
+
+<&| /page/info_section.mas, title=>"Graphics", collapsible=>1, collapsed=>1 &>
+
+    <label for="traitSelection">Select Trait:</label>
+    <select id="traitSelection" class="form-control">
+        <option value="" disabled selected>Select a trait</option>
+        <!-- Options will be dynamically populated -->
+    </select>
+
+    <div id="filterOptions" style="margin-bottom: 20px;">
+      <label><input type="radio" name="filter" value="5"> Show top 5%</label>
+      <label><input type="radio" name="filter" value="10" checked > Show top 10%</label>
+      <label><input type="radio" name="filter" value="25"> Show top 25%</label>
+      <label><input type="radio" name="filter" value="50"> Show top 50%</label>
+      <label><input type="radio" name="filter" value="100"> Show 100%</label>
+      <br>
+      <!-- Bottom filters -->
+      <label><input type="radio" name="filter" value="bottom-5"> Show bottom 5%</label>
+      <label><input type="radio" name="filter" value="bottom-25"> Show bottom 25%</label>
+      <label><input type="radio" name="filter" value="bottom-50"> Show bottom 50%</label>
+      <label><input type="radio" name="filter" value="bottom-75"> Show bottom 75%</label>
+    </div>
+
+    <br>
+
+    <div id="barplotContainer" style="width: 100%; height: 500px;"></div>
+    <br>
+    <div id="boxplotContainer" style="width: 100%; height: 500px;"></div>
+
+</&>
+
+<script>
+let currentPage = 1;   
+let itemsPerPage = 10; 
+let allData = [];
+
+document.getElementById('downloadCsvButton').addEventListener('click', function () {
+  // Prepare the headers for the CSV file
+  const headers = ['Accession', 'Trials', 'Observations', 'Trait', 'Average', 'SD', 'Min', 'Max'];
+
+  // Use the global `statisticsData` (or replace it with the actual variable holding all table data)
+  const rows = [];
+
+  Object.entries(stats).forEach(([trait, accessions]) => {
+    Object.entries(accessions).forEach(([accession, stats]) => {
+      rows.push([
+        accession, // Accession
+        stats.uniqueTrials || 0, // Trials
+        stats.uniquePlots || 0, // Observations
+        trait, // Trait
+        stats.mean !== undefined ? stats.mean.toFixed(2) : 'N/A', // Average
+        stats.stdDev !== undefined ? stats.stdDev.toFixed(2) : 'N/A', // SD
+        stats.min !== undefined ? stats.min.toFixed(2) : 'N/A', // Min
+        stats.max !== undefined ? stats.max.toFixed(2) : 'N/A', // Max
+      ]);
+    });
+  });
+
+  // Combine headers and rows into a single CSV string
+  const csvContent =
+    [headers.join(','), ...rows.map((row) => row.join(','))].join('\n');
+
+  // Create a Blob and a link to download the CSV
+  const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+  const url = URL.createObjectURL(blob);
+
+  const link = document.createElement('a');
+  link.href = url;
+  link.setAttribute('download', 'statistics_table.csv'); // Set the download file name
+  document.body.appendChild(link);
+  link.click(); // Trigger the download
+  document.body.removeChild(link); // Clean up the DOM
+});
+
+
+
+
+function drawD3Barplot(statsByTrait, selectedTrait) {
+  const traitStats = statsByTrait[selectedTrait];
+
+  if (!traitStats) {
+    alert('No data available for the selected trait!');
+    return;
+  }
+
+  // Get the selected filter option (e.g., "5", "10", "bottom-5")
+  const filterOption = $('input[name="filter"]:checked').val();
+
+  // Prepare data sorted by average
+  const sortedData = Object.keys(traitStats)
+    .map((accession) => {
+      const stat = traitStats[accession];
+      return {
+        accession: accession,
+        avg: stat.mean || 0,
+        min: stat.min || 0,
+        max: stat.max || 0,
+      };
+    })
+    .sort((a, b) => b.avg - a.avg); // Sort by average value (ascending for filtering)
+
+  let filteredData = []; // Initialize filteredData
+
+  // Apply filtering based on the selected option
+  if (!filterOption.startsWith('bottom')) {
+    // Top filtering (e.g., "5", "10", "25", etc.)
+    const percentage = parseInt(filterOption, 10); // Extract percentage from top option
+    const count = Math.ceil((percentage / 100) * sortedData.length);
+    filteredData = sortedData.slice(0, count); // Get the top entries
+  } else {
+    // Bottom filtering (e.g., "bottom-5", "bottom-25")
+    const percentage = parseInt(filterOption.split('-')[1], 10); // Extract percentage from "bottom-XX"
+    const count = Math.ceil((percentage / 100) * sortedData.length);
+    filteredData = sortedData.slice(-count); // Get the bottom entries
+  }
+
+  // Always show values ordered from major to minor
+  filteredData = filteredData.sort((a, b) => b.avg - a.avg); // Sort in descending order by average
+
+  // Clear the container
+  d3.select('#barplotContainer').html('');
+
+  // Set up dimensions
+  const margin = { top: 20, right: 30, bottom: 150, left: 60 }; // Increased bottom margin for long labels
+  const width = document.getElementById('barplotContainer').clientWidth - margin.left - margin.right;
+  const height = 500 - margin.top - margin.bottom;
+
+  // Append SVG
+  const svg = d3
+    .select('#barplotContainer')
+    .append('svg')
+    .attr('width', width + margin.left + margin.right)
+    .attr('height', height + margin.top + margin.bottom)
+    .append('g')
+    .attr('transform', `translate(${margin.left},${margin.top})`);
+
+  // Retrieve the color for the selected trait
+  const barColor = traitColorMap[selectedTrait] || '#17becf'; // Default color if not found
+
+  // Create scales
+  const xScale = d3.scaleBand().domain(filteredData.map((d) => d.accession)).range([0, width]).padding(0.4);
+  const yScale = d3
+    .scaleLinear()
+    .domain([0, d3.max(filteredData, (d) => d.max)])
+    .nice()
+    .range([height, 0]);
+
+  // Add axes
+  svg
+    .append('g')
+    .attr('transform', `translate(0,${height})`)
+    .call(d3.axisBottom(xScale))
+    .selectAll('text')
+    .attr('transform', 'rotate(45)') // Adjusted to 45 degrees for better readability
+    .attr('y', 10) // Fine-tuned y position
+    .attr('x', 5) // Adjusted x position for better alignment
+    .style('text-anchor', 'start')
+    .style('font-size', '10px'); // Reduced font size for clarity with many labels
+
+  svg.append('g').call(d3.axisLeft(yScale));
+
+  // Add bars
+  svg
+    .selectAll('.bar')
+    .data(filteredData)
+    .enter()
+    .append('rect')
+    .attr('class', 'bar')
+    .attr('x', (d) => xScale(d.accession))
+    .attr('y', (d) => yScale(d.avg))
+    .attr('width', xScale.bandwidth())
+    .attr('height', (d) => height - yScale(d.avg))
+    .attr('fill', barColor); // Use dynamically assigned color
+
+  // Add error bars (min and max)
+  svg
+    .selectAll('.error-line')
+    .data(filteredData)
+    .enter()
+    .append('line')
+    .attr('class', 'error-line')
+    .attr('x1', (d) => xScale(d.accession) + xScale.bandwidth() / 2)
+    .attr('x2', (d) => xScale(d.accession) + xScale.bandwidth() / 2)
+    .attr('y1', (d) => yScale(d.min))
+    .attr('y2', (d) => yScale(d.max))
+    .attr('stroke', 'black')
+    .attr('stroke-width', 1);
+
+  // Add min and max caps for error bars
+  svg
+    .selectAll('.error-cap-min')
+    .data(filteredData)
+    .enter()
+    .append('line')
+    .attr('class', 'error-cap-min')
+    .attr('x1', (d) => xScale(d.accession) + xScale.bandwidth() / 4)
+    .attr('x2', (d) => xScale(d.accession) + (3 * xScale.bandwidth()) / 4)
+    .attr('y1', (d) => yScale(d.min))
+    .attr('y2', (d) => yScale(d.min))
+    .attr('stroke', 'black')
+    .attr('stroke-width', 1);
+
+  svg
+    .selectAll('.error-cap-max')
+    .data(filteredData)
+    .enter()
+    .append('line')
+    .attr('class', 'error-cap-max')
+    .attr('x1', (d) => xScale(d.accession) + xScale.bandwidth() / 4)
+    .attr('x2', (d) => xScale(d.accession) + (3 * xScale.bandwidth()) / 4)
+    .attr('y1', (d) => yScale(d.max))
+    .attr('y2', (d) => yScale(d.max))
+    .attr('stroke', 'black')
+    .attr('stroke-width', 1);
+}
+
+
+
+// Event listener for the dropdown and filter options
+$('#traitSelection, input[name="filter"]').on('change', function () {
+  const selectedTrait = $('#traitSelection').val();
+  if (selectedTrait) {
+    drawD3Barplot(stats, selectedTrait); // Use global statsByTrait
+    drawGroupedBoxplot(selectedProjects, selectedTrait);
+  }
+});
+
+function drawGroupedBoxplot(data, selectedTrait) {
+    const container = document.getElementById('boxplotContainer');
+    if (!container || !container.clientWidth) {
+        console.error('Error: boxplotContainer is missing or not rendered.');
+        return;
+    }
+
+    const margin = { top: 20, right: 30, bottom: 150, left: 60 };
+    const width = container.clientWidth - margin.left - margin.right;
+    const height = 500 - margin.top - margin.bottom;
+
+    const svg = d3
+        .select('#boxplotContainer')
+        .html('') // Clear the previous plot
+        .append('svg')
+        .attr('width', width + margin.left + margin.right)
+        .attr('height', height + margin.top + margin.bottom)
+        .append('g')
+        .attr('transform', `translate(${margin.left},${margin.top})`);
+
+    // Filter the data to include only valid numerical values and the selected trait
+    const filteredData = data.filter(
+        (d) =>
+            d.value !== null &&
+            d.value !== undefined &&
+            !isNaN(parseFloat(d.value)) &&
+            d.trait === selectedTrait // Only include the selected trait
+    );
+
+    // Group data by trial
+    const groupedData = d3.group(filteredData, (d) => d.trial);
+
+    // Compute boxplot statistics, but only for trials that have valid data
+    const boxplotData = Array.from(groupedData, ([trial, trialData]) => {
+        const values = trialData.map((d) => parseFloat(d.value)).sort(d3.ascending);
+        if (values.length === 0) return null; // Exclude trials with no valid values
+        return {
+            trial,
+            q1: d3.quantile(values, 0.25),
+            median: d3.quantile(values, 0.5),
+            q3: d3.quantile(values, 0.75),
+            min: d3.min(values),
+            max: d3.max(values),
+            values, // Store all valid values for plotting dots
+        };
+    }).filter((d) => d !== null); // Remove null entries from boxplot data
+
+    // Define scales
+    const xScale = d3
+        .scaleBand()
+        .domain(boxplotData.map((d) => d.trial))
+        .range([0, width])
+        .padding(0.6); // Increased padding for more space between boxplots
+
+    const yScale = d3
+        .scaleLinear()
+        .domain([0, d3.max(boxplotData, (d) => d.max)])
+        .nice()
+        .range([height, 0]);
+
+    // Axes
+    svg.append('g')
+        .attr('transform', `translate(0,${height})`)
+        .call(d3.axisBottom(xScale))
+        .selectAll('text')
+        .attr('transform', 'rotate(45)')
+        .style('text-anchor', 'start');
+
+    svg.append('g').call(d3.axisLeft(yScale));
+
+    // Define color for the selected trait
+    const color = traitColorMap[selectedTrait] || '#69b3a2'; // Use a predefined color map or default
+
+    // Draw boxes
+    svg.selectAll('.box')
+        .data(boxplotData)
+        .enter()
+        .append('rect')
+        .attr('class', 'box')
+        .attr('x', (d) => xScale(d.trial))
+        .attr('y', (d) => yScale(d.q3))
+        .attr('width', xScale.bandwidth())
+        .attr('height', (d) => yScale(d.q1) - yScale(d.q3))
+        .attr('fill', color)
+        .attr('stroke', 'black');
+
+    // Draw median lines
+    svg.selectAll('.median-line')
+        .data(boxplotData)
+        .enter()
+        .append('line')
+        .attr('x1', (d) => xScale(d.trial))
+        .attr('x2', (d) => xScale(d.trial) + xScale.bandwidth())
+        .attr('y1', (d) => yScale(d.median))
+        .attr('y2', (d) => yScale(d.median))
+        .attr('stroke', 'black')
+        .attr('stroke-width', 2);
+
+    // Draw dots for all data points
+    boxplotData.forEach((d) => {
+        svg.selectAll(`.dot-${d.trial}`)
+            .data(d.values)
+            .enter()
+            .append('circle')
+            .attr('class', `dot-${d.trial}`)
+            .attr('cx', () =>
+                xScale(d.trial) +
+                xScale.bandwidth() / 2 +
+                (Math.random() - 0.5) * (xScale.bandwidth() * 0.5) // Random horizontal spread
+            )
+            .attr('cy', (value) => yScale(value))
+            .attr('r', 4) // Radius of the dots
+            .attr('fill', 'black')
+            .attr('opacity', 0.6);
+    });
+
+    // Draw whiskers (min and max)
+    svg.selectAll('.whisker')
+        .data(boxplotData)
+        .enter()
+        .append('line')
+        .attr('class', 'whisker')
+        .attr('x1', (d) => xScale(d.trial) + xScale.bandwidth() / 2)
+        .attr('x2', (d) => xScale(d.trial) + xScale.bandwidth() / 2)
+        .attr('y1', (d) => yScale(d.min))
+        .attr('y2', (d) => yScale(d.max))
+        .attr('stroke', 'black')
+        .attr('stroke-width', 1);
+}
+
+
+let traitColorMap = {}; 
+
+
+// Function to populate the trait selection dropdown
+function populateTraitSelection(stats) {
+  // Get the dropdown element
+  const traitSelection = $('#traitSelection');
+
+  // Clear existing options (if any)
+  traitSelection.empty();
+
+  // Add a default option
+  traitSelection.append('<option value="" disabled selected>Select a trait</option>');
+
+  // Get the traits from the stats object and populate the dropdown
+  const traits = Object.keys(stats); // Traits are the top-level keys in the stats object
+  traits.forEach((trait) => {
+    traitSelection.append(`<option value="${trait}">${trait}</option>`);
+  });
+
+  // Enable the dropdown if it was disabled
+  traitSelection.prop('disabled', traits.length === 0);
+}
+
+function calculateStatisticsPerTrait(data) {
+  const statsByTrait = {};
+
+  // Generate a unique color for each trait
+  const colorPalette = d3.schemeCategory10; // Use D3's built-in color palette
+  let colorIndex = 0;
+
+  // Group data by trait and accession
+  data.forEach((record) => {
+    // Extract relevant fields from the record
+    const { trait, accession, plot, trial, value } = record;
+
+    if (!traitColorMap[trait]) {
+      traitColorMap[trait] = colorPalette[colorIndex % colorPalette.length];
+      colorIndex++;
+    }
+
+    // Initialize the trait in the stats object if not already present
+    if (!statsByTrait[trait]) {
+      statsByTrait[trait] = {};
+    }
+
+    // Initialize the accession within the trait if not already present
+    if (!statsByTrait[trait][accession]) {
+      statsByTrait[trait][accession] = {
+        uniquePlots: new Set(), // Use a Set to track unique plots
+        uniqueTrials: new Set(), // Use a Set to track unique trials
+        values: [], // Store all valid values for calculations
+      };
+    }
+
+    // Update the stats for this accession under this trait
+    statsByTrait[trait][accession].uniquePlots.add(plot);
+    statsByTrait[trait][accession].uniqueTrials.add(trial);
+
+    // Add the value if it's a valid number
+    const numericValue = parseFloat(value);
+    if (!isNaN(numericValue)) {
+      statsByTrait[trait][accession].values.push(numericValue);
+    }
+  });
+
+  // Calculate derived statistics for each trait and accession
+  for (const trait in statsByTrait) {
+    for (const accession in statsByTrait[trait]) {
+      const accessionData = statsByTrait[trait][accession];
+      const validValues = accessionData.values;
+
+      // Calculate statistics if valid values exist
+      if (validValues.length > 0) {
+        const minValue = Math.min(...validValues);
+        const maxValue = Math.max(...validValues);
+        const mean =
+          validValues.reduce((sum, val) => sum + val, 0) / validValues.length;
+        const variance =
+          validValues.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) /
+          validValues.length;
+        const stdDev = Math.sqrt(variance);
+
+        // Update the stats object
+        statsByTrait[trait][accession] = {
+          uniquePlots: accessionData.uniquePlots.size, // Count unique plots
+          uniqueTrials: accessionData.uniqueTrials.size, // Count unique trials
+          count: validValues.length, // Total number of valid values
+          min: minValue,
+          max: maxValue,
+          mean: mean,
+          stdDev: stdDev,
+        };
+      } else {
+        // If no valid values, set stats to null
+        statsByTrait[trait][accession] = {
+          uniquePlots: accessionData.uniquePlots.size,
+          uniqueTrials: accessionData.uniqueTrials.size,
+          count: 0, // No valid values
+          min: null,
+          max: null,
+          mean: null,
+          stdDev: null,
+        };
+      }
+    }
+  }
+
+  return statsByTrait;
+}
+
+let stats = {};
+
+
+// Example usage with an AJAX call
+$(document).ready(function () {
+  $('#calculate_statistics').on('click', function () {
+    $('#loading_spinner').show();
+
+    $.ajax({
+      url: '/ajax/validatedtrials/getphenotype',
+      type: 'POST',
+      data: { projectTrait: JSON.stringify(allProjects) },
+      dataType: 'json',
+      success: function (response) {
+        
+        //sending data to boxplot
+        selectedProjects = response;
+
+        // Call the function to calculate statistics
+        stats = calculateStatisticsPerTrait(response);
+
+        // Populate the table with the results
+        populateStatisticsTable(stats);
+
+        // Populate the trait selection dropdown
+        populateTraitSelection(stats);
+
+        // Integrate pagination if needed
+        $('#statTable').DataTable();
+
+      },
+      error: function (xhr, status, error) {
+        console.error('Error:', error);
+        alert('An error occurred while calculating statistics.');
+      },
+      complete: function () {
+        $('#loading_spinner').hide();
+      },
+    });
+  });
+});
+
+// Function to populate the statistics table
+function populateStatisticsTable(stats) {
+  // Clear existing table rows
+  $('#statTable tbody').empty();
+
+  // Iterate through the stats object to populate the table
+  for (const trait in stats) {
+    for (const accession in stats[trait]) {
+      const stat = stats[trait][accession];
+
+      // Create a new row
+      const row = `
+        <tr>
+          <td>${accession}</td>
+          <td>${stat.uniqueTrials}</td>
+          <td>${stat.count}</td>
+          <td>${trait}</td>
+          <td>${stat.mean !== null ? stat.mean.toFixed(2) : "N/A"}</td>
+          <td>${stat.stdDev !== null ? stat.stdDev.toFixed(2) : "N/A"}</td>
+          <td>${stat.min !== null ? stat.min.toFixed(2) : "N/A"}</td>
+          <td>${stat.max !== null ? stat.max.toFixed(2) : "N/A"}</td>
+        </tr>
+      `;
+
+      // Append the row to the table body
+      $('#statTable tbody').append(row);
+    }
+  }
+}
+
+
+
+/// Array to store selected location names
+let selectedLocations = [];
+let allProjects = [];
+let selectedProjects = [];
+
+$(document).on('change', '.projectCheckbox', function () {
+    const projectName = $(this).data('name');
+    const validatedTrait = $(this).data('trait');
+
+    if ($(this).is(':checked')) {
+        // Check if the combination of name and trait already exists in allProjects
+        const exists = allProjects.some(
+            (project) =>
+                project.name === projectName &&
+                project.validated_trait === validatedTrait
+        );
+
+        if (!exists) {
+            allProjects.push({
+                name: projectName,
+                validated_trait: validatedTrait,
+            });
+        }
+
+        // Ensure the name exists in selectedLocations
+        if (!selectedLocations.includes(projectName)) {
+            selectedLocations.push(projectName);
+        }
+    } else {
+        // Remove only the specific combination of name and trait
+        allProjects = allProjects.filter(
+            (project) =>
+                !(project.name === projectName && project.validated_trait === validatedTrait)
+        );
+
+        // Check if the projectName still has any associated traits in allProjects
+        const hasOtherTraits = allProjects.some(
+            (project) => project.name === projectName
+        );
+
+        // Remove the projectName from selectedLocations if no traits are left
+        if (!hasOtherTraits) {
+            selectedLocations = selectedLocations.filter(
+                (name) => name !== projectName
+            );
+        }
+    }
+    console.log("here sel loc:", selectedLocations);
+    // Call fetchLatLonForProjects only with unique selectedLocations
+    if (selectedLocations.length > 0) {
+        fetchLatLonForProjects([...new Set(selectedLocations)]);
+    }
+});
+
+
+
+
+
+
+
+$(document).ready(function() {
+    fetchProjectData();
+
+    // Set items per page from localStorage if previously selected
+    const storedItemsPerPage = localStorage.getItem("itemsPerPage");
+    if (storedItemsPerPage) {
+        itemsPerPage = parseInt(storedItemsPerPage);
+        $("#itemsPerPage").val(itemsPerPage);
+    }
+});
+
+
+function displayData(data) {
+    const startIndex = (currentPage - 1) * itemsPerPage;
+    const pagedData = data.slice(startIndex, startIndex + itemsPerPage);
+
+    // Clear the existing table rows
+    $('#projectDataTable tbody').empty();
+
+    // Populate the table with paged data and ensure project name goes in the second column
+    pagedData.forEach(function(project) {
+        $('#projectDataTable tbody').append(
+            `<tr>
+                <td><input type="checkbox" class="projectCheckbox" data-name="${project.name}" data-trait="${project.validated_trait}">
+                <td>${project.name}</td>  <!-- Project Name in the second column -->
+                <td>${project.project_location}</td>
+                <td>${project.validated_trait}</td>
+                <td>${project.username}</td>
+            </tr>`
+        );
+    });
+}
+
+function fetchLatLonForProjects(selectedLocations) {
+    $.ajax({
+        url: '/ajax/validatedtrials/getcoordinates',
+        method: 'POST',
+        data: { locNames: JSON.stringify(selectedLocations) },
+        success: function(response) {
+            
+            try {
+                // Ensure response is parsed as JSON
+                const coordinates = typeof response === 'string' ? JSON.parse(response) : response;
+                // Check the structure of the parsed data
+                if (!Array.isArray(coordinates)) {
+                    console.error('Expected an array but got:', coordinates);
+                    return;
+                }
+                // Pass the data to the map update function
+                updateMapWithSelectedProjects(coordinates);
+            } catch (error) {
+                console.error('Error processing server response:', error);
+            }
+        },
+        error: function(xhr, status, error) {
+            console.error('AJAX Error:', {
+                status: status,
+                error: error,
+                responseText: xhr.responseText
+            });
+        }
+    });
+}
+
+// Initialize the map
+var map = L.map('map').setView([0, 0], 2);  // Default view set to the whole world
+
+// Add OpenStreetMap tiles
+L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+    attribution: '&copy; OpenStreetMap contributors'
+}).addTo(map);
+
+// Ensure the map size is adjusted properly
+setTimeout(function () {
+    map.invalidateSize();
+
+    const container = document.getElementById('boxplotContainer');
+    if (!container || !container.clientWidth) {
+      console.error('Error: boxplotContainer is missing or not rendered.');
+      return;
+    }
+
+}, 100); // Delay for 100ms to ensure the container is fully rendered
+
+
+
+function updateMapWithSelectedProjects(coordinates) {
+    // Clear existing markers
+    if (typeof map !== 'undefined') {
+        map.eachLayer(function(layer) {
+            if (layer instanceof L.Marker) {
+                map.removeLayer(layer);
+            }
+        });
+    }
+
+    // Add new markers
+    coordinates.forEach(coord => {
+        if (coord.latitude !== undefined && coord.longitude !== undefined) {
+            // Create marker and bind popup with the name only
+            L.marker([coord.latitude, coord.longitude])
+                .addTo(map)
+                .bindPopup(`<span>${coord.name}</span>`) // Display only the name in the popup
+                .openPopup();
+        } else {
+            console.error('Skipping invalid coordinate:', coord);
+        }
+    });
+}
+
+
+
+// Trigger the updateMapWithSelectedProjects function when the checkboxes change
+$(document).on('change', '.projectCheckbox', function() {
+    updateMapWithSelectedProjects();
+});
+
+
+function filterTable() {
+    const query = document.getElementById("searchBox").value.toLowerCase();
+    const filteredData = allData.filter(project => {
+        return project.name.toLowerCase().includes(query) ||
+               project.project_location.toLowerCase().includes(query) ||
+               project.validated_trait.toLowerCase().includes(query);
+    });
+    displayData(filteredData);
+    updatePaginationControls(filteredData);
+}
+
+function changePage(offset) {
+    currentPage += offset;
+    displayData(allData);
+    updatePaginationControls(allData);
+}
+
+function updatePaginationControls(data) {
+    const totalPages = Math.ceil(data.length / itemsPerPage);
+    currentPage = Math.min(Math.max(1, currentPage), totalPages); 
+
+    // Enable/disable the buttons based on the current page
+    document.getElementById("prevPageBtn").disabled = currentPage === 1;
+    document.getElementById("nextPageBtn").disabled = currentPage === totalPages;
+    
+    document.getElementById("currentPageLabel").textContent = `Page ${currentPage} of ${totalPages}`;
+}
+
+
+
+function setItemsPerPage() {
+    itemsPerPage = parseInt(document.getElementById("itemsPerPage").value);
+    localStorage.setItem("itemsPerPage", itemsPerPage);
+    displayData(allData);
+    updatePaginationControls(allData);
+}
+
+function fetchProjectData() {
+    $.ajax({
+        url: '/ajax/validatedtrials/grabdata', 
+        method: "GET",
+        dataType: "json",
+        success: function(response) {
+            if (response && response.data && Array.isArray(response.data)) {
+                allData = response.data; 
+                displayData(allData); 
+                updatePaginationControls(allData);
+            } else {
+                alert("No valid data found or data format issue");
+            }
+        },
+        error: function() {
+            alert("An error occurred while fetching project data.");
+        }
+    });
+}
+
+
+
+
+// Initialize the base map
+function initializeBaseMap() {
+    // Assuming "map" is the global Leaflet map variable
+    if (!map) {
+        map = L.map('map').setView([0, 0], 2); // Default view (adjust lat/lon and zoom as needed)
+    }
+
+    // Add a tile layer (adjust the URL if needed)
+    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+        maxZoom: 19,
+        attribution: '© OpenStreetMap contributors'
+    }).addTo(map);
+}
+
+
+
+// Add markers for each location
+locations.forEach(function(location) {
+    L.marker([location.lat, location.lon])
+        .addTo(map)
+        .bindPopup(location.name);
+});
+
+// Ensure map resizes properly when zooming
+map.on('resize', function() {
+    map.invalidateSize();
+});
+
+// Optional: Trigger invalidateSize() if the map is not resizing correctly
+window.addEventListener('load', function() {
+    map.invalidateSize();
+});
+
+// Trigger invalidateSize on window resize to ensure the map fits properly
+window.addEventListener('resize', function() {
+    map.invalidateSize();
+});
+
+
+</script>
+
+
+<style>
+
+html, body {
+    height: 100%;
+    margin: 0;
+}
+
+#map { 
+    height: 500px;
+    width: 100%
+}
+
+.search-container {
+    text-align: right;
+    margin: 10px;
+}
+
+#searchBox {
+    padding: 5px;
+    width: 200px; /* Adjust the width as needed */
+}
+
+input[type="checkbox"] {
+    width: 20px;
+    height: 20px;
+}
+
+
+.factor {
+    z-index:4;
+    border-style:solid;
+    border-radius:8px;
+    width:200px;
+    height:100;
+    border-color:#337ab7;
+    background-color:#337ab7;
+    color:white;
+    margin:4px
+}
+.factor_panel {
+    min-height:100px;
+    height:auto;
+    margin-top:0px;
+    border-style:dotted;
+    border-width:5px;
+    color:grey;
+    background-color:lightyellow;
+}
+    .factor_interaction_panel {
+    border-style:dotted;
+    border-width:0px;
+    margin-top:20px;
+    height:auto;
+    z-index:1;
+}
+.model_bg {
+    margin-left:30px;
+    margin-right:30px;
+    background-color:#DDEEEE;
+    min-height:80px;
+    padding-top:10px;
+    padding-left:10px;
+    padding-bottom:10px;
+    border-radius:8px;
+}
+</style>
diff --git a/mason/tools/stability/index.mas b/mason/tools/stability/index.mas
index b295cfda61..998b940d25 100644
--- a/mason/tools/stability/index.mas
+++ b/mason/tools/stability/index.mas
@@ -51,6 +51,9 @@
         <br>
         </div>
       <div class = "form-group form-inline">
+       <input type="checkbox" id="dataset_trait_outliers" />
+       <label>Exclude dataset outliers &nbsp; </label>
+       <br>      
        <label for = select_method>Available Methods: </label>
        <select class="form-control input-sm" id="select_method">
         <option selected value="method_empty"></option>
@@ -135,6 +138,18 @@
 
 <script>
 
+var require_login = "<%  $c->get_conf('brapi_require_login') %>";
+if (require_login === '1'){
+    auth_token = "<%  CXGN::Login->new($c->dbc->dbh)->get_login_cookie() %>";
+    if (!auth_token){ alert("Login required to display heritability"); }
+}
+
+var check_outliers = "<% $c->get_conf('exclude_phenotype_outliers') || 0 %>";
+
+if (parseInt(check_outliers) === 1) {
+    document.getElementById('dataset_trait_outliers').checked = true;
+}
+
 jQuery(document).ready(function() {
   if (isLoggedIn()) {
     get_select_box("datasets", "dataset_select", {"checkbox_name":"dataset_select_checkbox"});
@@ -313,7 +328,7 @@ jQuery('#runAMMI').click( function () {
             var trait_id = $('#pheno_select').val();
             var method_id = $('#select_method').val();
             var imput_id = $('#select_imput').val();
-            var dataset_trait_outliers = 0;
+            var dataset_trait_outliers = $('#dataset_trait_outliers').is(':checked') ? 1 : 0;
             $.ajax({
                 url: '/ajax/stability/generate_results',
                 data: {
diff --git a/sgn_test.conf b/sgn_test.conf
index da3f2f4d7c..08f0dccb4c 100644
--- a/sgn_test.conf
+++ b/sgn_test.conf
@@ -13,6 +13,8 @@ main_production_site_url http://localhost
 supportedCrop   Cassava
 preferred_species Manihot esculenta
 
+exclude_phenotype_outliers = 1
+
 # Ontology options
 composable_cvs trait,attribute,tod,toy
 composable_cvs_allowed_combinations Image|trait+attribute+tod+toy