Fourteenth deployment (Add Trust Builder computation and tables)

Dockerfile

@@ -17,7 +17,7 @@ RUN apt-get update && apt-get install -y \
  && rm -rf /var/lib/apt/lists/*
 
 # Install R packages
-RUN R -e "install.packages(c('relaimpo', 'readxl', 'readr'), repos='http://cran.rstudio.com/')"
+RUN R -e "install.packages(c('relaimpo', 'readxl', 'readr', 'lavaan', 'leaps', 'dplyr', 'tidyr'), repos='http://cran.rstudio.com/')"
 
 # Copy the requirements.txt file, your app script, and the R script into the container.
 COPY requirements.txt /requirements.txt

app.py

@@ -159,10 +159,12 @@ def call_r_script(
     csv_output_path_loyalty,
     csv_output_path_consideration,
     csv_output_path_satisfaction,
+    csv_output_path_trustbuilder,
     nps_present,
     loyalty_present,
     consideration_present,
     satisfaction_present,
+    trustbuilder_present,
 ):
     """
     Call the R script for Shapley regression analysis.
@@ -191,10 +193,12 @@ def call_r_script(
         csv_output_path_loyalty,
         csv_output_path_consideration,
         csv_output_path_satisfaction,
+        csv_output_path_trustbuilder,
         str(nps_present).upper(),  # Convert the boolean to a string ("TRUE" or "FALSE")
         str(loyalty_present).upper(),
         str(consideration_present).upper(),
         str(satisfaction_present).upper(),
+        str(trustbuilder_present).upper(),
     ]
 
     try:
@@ -234,13 +238,22 @@ def analyze_excel_single(file_path):
         ".txt", "_consideration.csv"
     )
     csv_output_path_satisfaction = text_output_path.replace(".txt", "_satisfaction.csv")
+    csv_output_path_trustbuilder = text_output_path.replace(".txt", "_trustbuilder.csv")
 
-    # Load the dataset (CSV or Excel)
+    # Load the Trust Driver dataset (CSV or Excel)
+    # Trust Driver dataset is mandatory
     df = None
-    if ".xlsx" in file_path:
-        df = pd.read_excel(file_path)
-    elif ".csv" in file_path:
-        df = pd.read_csv(file_path)
+    trustbuilder_present = False
+
+    # if ".xlsx" in file_path:
+    excel_file = pd.ExcelFile(file_path)
+    df = pd.read_excel(file_path, sheet_name="Driver")
+
+    # Check if Driver and Builder sheets are present in the dataset
+    trustbuilder_present = "Builder" in excel_file.sheet_names
+
+    # elif ".csv" in file_path:
+    #     df = pd.read_csv(file_path)
 
     # Step 1: Check for missing columns and handle NPS column
     required_columns = [
@@ -300,6 +313,7 @@ def analyze_excel_single(file_path):
         )
 
     # Step 3: Adjust Shapley regression analysis based on column presence
+    # Handle Trust Driver Analysis and Trust Builder Analysis
     call_r_script(
         file_path,
         text_output_path,
@@ -308,10 +322,12 @@ def analyze_excel_single(file_path):
         csv_output_path_loyalty,
         csv_output_path_consideration,
         csv_output_path_satisfaction,
+        csv_output_path_trustbuilder,
         nps_present,
         loyalty_present,
         consideration_present,
         satisfaction_present,
+        trustbuilder_present,
     )
 
     # Read the output text file
@@ -326,6 +342,7 @@ def analyze_excel_single(file_path):
     results_df_trust = pd.read_csv(csv_output_path_trust)
     results_df_trust["Importance_percent"] = results_df_trust["Importance"] * 100
     average_value_trust = results_df_trust["Importance_percent"].mean()
+
     img_trust = plot_model_results(
         results_df_trust,
         average_value_trust,
@@ -411,6 +428,79 @@ def analyze_excel_single(file_path):
             "Satisfaction",
         )
 
+    df_builder = None
+    df_builder_pivot = None
+    if trustbuilder_present:
+        # Create dataframe for trust builder
+        results_df_builder = pd.read_csv(csv_output_path_trustbuilder)
+
+        combined_data = {
+            "Message": results_df_builder["Message"],
+            "Stability": results_df_builder["Stability"].round(0).astype(int),
+            "Development": results_df_builder["Development"].round(0).astype(int),
+            "Relationship": results_df_builder["Relationship"].round(0).astype(int),
+            "Benefit": results_df_builder["Benefit"].round(0).astype(int),
+            "Vision": results_df_builder["Vision"].round(0).astype(int),
+            "Competence": results_df_builder["Competence"].round(0).astype(int),
+        }
+
+        df_builder = pd.DataFrame(combined_data)
+
+        # Create consolidated table
+        # List of bucket columns
+        bucket_columns = [
+            "Stability",
+            "Development",
+            "Relationship",
+            "Benefit",
+            "Vision",
+            "Competence",
+        ]
+
+        # Prepare lists to collect data
+        buckets = []
+        messages = []
+        percentages = []
+
+        # Iterate through each bucket column
+        for bucket in bucket_columns:
+            for index, value in results_df_builder[bucket].items():
+                if value > 0:
+                    buckets.append(bucket)
+                    messages.append(results_df_builder["Message"][index])
+                    percentages.append(int(round(value)))
+
+        # Create the new DataFrame
+        builder_consolidated = {
+            "Trust Driver®": buckets,
+            "Trust Proof Point®": messages,
+            "%": percentages,
+        }
+
+        df_builder_pivot = pd.DataFrame(builder_consolidated)
+
+        # Define the order of the Trust Driver® categories
+        trust_driver_order = [
+            "Stability",
+            "Development",
+            "Relationship",
+            "Benefit",
+            "Vision",
+            "Competence",
+        ]
+
+        # Convert Trust Driver® column to a categorical type with the specified order
+        df_builder_pivot["Trust Driver®"] = pd.Categorical(
+            df_builder_pivot["Trust Driver®"],
+            categories=trust_driver_order,
+            ordered=True,
+        )
+
+        # Sort the DataFrame by 'Trust Driver®' and '%' in descending order within each 'Trust Driver®'
+        df_builder_pivot = df_builder_pivot.sort_values(
+            by=["Trust Driver®", "%"], ascending=[True, False]
+        )
+
     # After processing, ensure to delete the temporary files and directory
     os.remove(csv_output_path_trust)
     if nps_present:
@@ -421,6 +511,8 @@ def analyze_excel_single(file_path):
         os.remove(csv_output_path_consideration)
     if satisfaction_present:
         os.remove(csv_output_path_satisfaction)
+    if trustbuilder_present:
+        os.remove(csv_output_path_trustbuilder)
     os.remove(text_output_path)
     os.rmdir(temp_dir)
 
@@ -454,6 +546,8 @@ def analyze_excel_single(file_path):
         img_loyalty,
         img_consideration,
         img_satisfaction,
+        df_builder,
+        df_builder_pivot,
         output_text,
     )
 
@@ -480,6 +574,8 @@ def batch_file_processing(file_paths):
     img_loyalty_list = []
     img_consideration_list = []
     img_satisfaction_list = []
+    df_builder_list = []
+    df_builder_pivot_list = []
     output_text_list = []
 
     for file_path in file_paths:
@@ -489,6 +585,8 @@ def batch_file_processing(file_paths):
             img_loyalty,
             img_consideration,
             img_satisfaction,
+            df_builder,
+            df_builder_pivot,
             output_text,
         ) = analyze_excel_single(file_path)
         img_trust_list.append(img_trust)
@@ -496,6 +594,8 @@ def batch_file_processing(file_paths):
         img_loyalty_list.append(img_loyalty)
         img_consideration_list.append(img_consideration)
         img_satisfaction_list.append(img_satisfaction)
+        df_builder_list.append(df_builder)
+        df_builder_pivot_list.append(df_builder_pivot)
         output_text_list.append(output_text)
 
     return (
@@ -504,6 +604,8 @@ def batch_file_processing(file_paths):
         img_loyalty_list,
         img_consideration_list,
         img_satisfaction_list,
+        df_builder_list,
+        df_builder_pivot_list,
         output_text_list,
     )
 
@@ -525,7 +627,7 @@ outputs = []
 
 def variable_outputs(file_inputs):
 
-    file_inputs_single = [file_inputs]  ## special handling for single file
+    file_inputs_single = file_inputs
 
     # Call batch file processing and get analysis results
     (
@@ -534,6 +636,8 @@ def variable_outputs(file_inputs):
         img_loyalty_list,
         img_consideration_list,
         img_satisfaction_list,
+        df_builder_list,
+        df_builder_pivot_list,
         output_text_list,
     ) = batch_file_processing(file_inputs_single)
 
@@ -550,6 +654,8 @@ def variable_outputs(file_inputs):
         img_loyalty,
         img_consideration,
         img_satisfaction,
+        df_builder,
+        df_builder_pivot,
         output_text,
     ) in enumerate(
         zip_longest(
@@ -558,6 +664,8 @@ def variable_outputs(file_inputs):
             img_loyalty_list,
             img_consideration_list,
             img_satisfaction_list,
+            df_builder_list,
+            df_builder_pivot_list,
             output_text_list,
         )
     ):
@@ -603,6 +711,24 @@ def variable_outputs(file_inputs):
             #     #label=f"{dataset_name}: Analysis Summary",
             #     visible=False,
             # ),
+            gr.Dataframe(
+                value=df_builder,
+                headers=list(df_builder.columns),
+                interactive=False,
+                label=f"{dataset_name}",
+                visible=True,
+                height=800,
+                wrap=True,
+            ),
+            gr.Dataframe(
+                value=df_builder_pivot,
+                headers=list(df_builder_pivot.columns),
+                interactive=False,
+                label=f"{dataset_name}",
+                visible=True,
+                height=800,
+                wrap=True,
+            ),
         ]
 
         # add current plots to container
@@ -617,6 +743,8 @@ def variable_outputs(file_inputs):
         # gr.Textbox(label="Analysis Summary", visible=False),
         gr.Image(label="Trust Drivers", visible=False),
         gr.Image(label="NPS Drivers", visible=False),
+        gr.Dataframe(label=" ", visible=False),
+        gr.Dataframe(label=" ", visible=False),
     ]
 
     return plots_visible + plots_invisible * (max_outputs - k)
@@ -639,8 +767,12 @@ def reset_outputs():
     # summary_text = gr.Textbox(value=None, label="Analysis Summary", visible=False)
     trust_plot = gr.Image(value=None, label="Trust Drivers", visible=True)
     nps_plot = gr.Image(value=None, label="NPS Drivers", visible=True)
+    df_builder = gr.Dataframe(value=None, label=" ", visible=True)
+    df_builder_pivot = gr.Dataframe(value=None, label=" ", visible=True)
     outputs.append(trust_plot)
     outputs.append(nps_plot)
+    outputs.append(df_builder)
+    outputs.append(df_builder_pivot)
     # outputs.append(loyalty_plot)
     # outputs.append(satisfaction_plot)
     # outputs.append(consideration_plot)
@@ -662,8 +794,12 @@ def reset_outputs():
         # summary_text = gr.Textbox(value=None, label="Analysis Summary", visible=False)
         trust_plot = gr.Image(value=None, label="Trust Drivers", visible=False)
         nps_plot = gr.Image(value=None, label="NPS Drivers", visible=False)
+        df_builder = gr.Dataframe(value=None, label=" ", visible=False)
+        df_builder_pivot = gr.Dataframe(value=None, label=" ", visible=False)
         outputs.append(trust_plot)
         outputs.append(nps_plot)
+        outputs.append(df_builder)
+        outputs.append(df_builder_pivot)
         # outputs.append(loyalty_plot)
         # outputs.append(consideration_plot)
         # outputs.append(satisfaction_plot)
@@ -674,40 +810,88 @@ def reset_outputs():
 
 def process_examples(file_name):
     file_path = f"example_files/{file_name[0]}"
-    outputs = variable_outputs(file_path)  ## special handling for single file
+    file_path = [file_path]
+    outputs = variable_outputs(file_path)
     return outputs
 
 
+# with gr.Blocks() as demo:
+#     with gr.Row():
+#         with gr.Column():
+#             # title = gr.Markdown("# TrustLogic & NPS Driver Analysis (Batch Version)")
+#             # description = gr.Markdown(instruction_text)
+
+#             with gr.Row():
+#                 dataset = gr.Dataset(
+#                     components=[gr.Textbox(visible=False)],
+#                     label="Select an example to calculate the Trust Drivers from the underlying Excel files",
+#                     type="values",
+#                     samples=[
+#                         ["VW.xlsx"],
+#                         # ["HSBC.xlsx"],
+#                         # ["CBA.xlsx"],
+#                         # ["Red Cross.xlsx"],
+#                         # ["Health Insurance.xlsx"],
+#                         # ["WV.xlsx"],
+#                         # ["Care.xlsx"],
+#                         # ["BUPA.xlsx"],
+#                     ],
+#                 )
+
+#             with gr.Row():
+#                 # set file upload widget
+#                 file_inputs = gr.File(label="Excel Dataset")
+
+#             with gr.Row():
+#                 # set clear and submit butttons
+#                 clear_button = gr.ClearButton(file_inputs)
+#                 submit_button = gr.Button("Submit", variant="primary")
+
+#         with gr.Column():
+#             # set default output widgets
+#             outputs = reset_outputs()
+
+#         # function for submit button click
+#         submit_button.click(fn=variable_outputs, inputs=file_inputs, outputs=outputs)
+
+#         # function for clear button click
+#         # this only handles the outputs. Input reset is handled at button definition
+#         clear_button.click(fn=reset_outputs, inputs=[], outputs=outputs)
+
+#         # function for example files
+#         dataset.click(fn=process_examples, inputs=dataset, outputs=outputs)
+
 with gr.Blocks() as demo:
-    with gr.Row():
-        with gr.Column():
-            # title = gr.Markdown("# TrustLogic & NPS Driver Analysis (Batch Version)")
-            # description = gr.Markdown(instruction_text)
-
-            with gr.Row():
-                dataset = gr.Dataset(
-                    components=[gr.Textbox(visible=False)],
-                    label="Select an example to calculate the Trust Drivers from the underlying Excel files",
-                    type="values",
-                    samples=[
-                        ["HSBC.xlsx"],
-                        ["CBA.xlsx"],
-                        ["Red Cross.xlsx"],
-                        ["Health Insurance.xlsx"],
-                        ["WV.xlsx"],
-                        ["Care.xlsx"],
-                        ["BUPA.xlsx"],
-                    ],
-                )
-
-            with gr.Row():
-                # set file upload widget
-                file_inputs = gr.File(label="Excel/CSV Dataset")
-
-            with gr.Row():
-                # set clear and submit butttons
-                clear_button = gr.ClearButton(file_inputs)
-                submit_button = gr.Button("Submit", variant="primary")
+    # with gr.Column():
+    #     title = gr.Markdown("# TrustLogic & NPS Driver Analysis (Batch Version)")
+    #     description = gr.Markdown(instruction_text)
+
+    with gr.Column():
+        with gr.Row():
+            dataset = gr.Dataset(
+                components=[gr.Textbox(visible=False)],
+                label="Select an example to calculate the Donor Drivers from the underlying Excel files",
+                type="values",
+                samples=[
+                    ["VW.xlsx"],
+                    # ["HSBC.xlsx"],
+                    # ["CBA.xlsx"],
+                    # ["Red Cross.xlsx"],
+                    # ["Health Insurance.xlsx"],
+                    # ["WV.xlsx"],
+                    # ["Care.xlsx"],
+                    # ["BUPA.xlsx"],
+                ],
+            )
+
+        with gr.Row():
+            # set file upload widget
+            file_inputs = gr.Files(label="Excel Dataset")
+
+        with gr.Row():
+            # set clear and submit butttons
+            clear_button = gr.ClearButton(file_inputs)
+            submit_button = gr.Button("Submit", variant="primary")
 
         with gr.Column():
             # set default output widgets

process_data.R

@@ -1,34 +1,199 @@
 # Load required libraries
+library(relaimpo)
 library(readxl)
 library(readr)
-library(relaimpo)
+library(lavaan)
+library(leaps)
+library(dplyr)
+library(tidyr)
+
+# Logging function
+log_message <- function(message, output_text_file) {
+  cat(message, "\n")
+  write(message, file = output_text_file, append = TRUE)
+}
+
+# Trust Driver analysis function
+trust_driver_analysis <- function(model_formula, data, output_text_file, csv_file) {
+  tryCatch({
+    # Fit linear regression model
+    model <- lm(model_formula, data = data)
+
+    # Calculate relative importance using the lmg method
+    calc_relaimpo <- calc.relimp(model, type = "lmg", rela = TRUE)
+    # Calculate average importance
+    average_importance <- mean(calc_relaimpo$lmg)
+
+    # Open the output text file in append mode to add this model's output
+    file_conn <- file(output_text_file, open = "a")
+    # Capture output to include in the text file
+    full_output <- capture.output({
+      print("Trust Driver Analysis:\n")
+      print(calc_relaimpo)
+      cat("\nAverage Importance: ", average_importance, "\n")
+    })
+    # Write output to text file
+    writeLines(full_output, file_conn)
+    close(file_conn)
 
-# Define function to process each model
-process_model <- function(model_formula, data, output_text_file, csv_file) {
-  # Fit linear regression model
-  model <- lm(model_formula, data = data)
-
-  # Calculate relative importance using the lmg method
-  calc_relaimpo <- calc.relimp(model, type = "lmg", rela = TRUE)
-  # Calculate average importance
-  average_importance <- mean(calc_relaimpo$lmg)
-
-  # Open the output text file in append mode to add this model's output
-  file_conn <- file(output_text_file, open = "a")
-  # Capture output to include in the text file
-  full_output <- capture.output({
-    print(calc_relaimpo)
-    cat("\nAverage Importance: ", average_importance, "\n")
+    # Create data frame of predictor names and their importance
+    results <- data.frame(Predictor = names(calc_relaimpo$lmg), Importance = calc_relaimpo$lmg)
+
+    # Save results to CSV file
+    write.csv(results, file = csv_file, row.names = FALSE)
+  }, error = function(e) {
+    log_message(paste("Error in trust_driver_analysis:", e$message), output_text_file)
   })
-  # Write output to text file
-  writeLines(full_output, file_conn)
-  close(file_conn)
+}
+
+# Trust Builder Analysis function
+trust_builder_analysis <- function(data, data_headers, output_text_file, csv_file) {
+  tryCatch({
+    # Map the questions to column names
+    question_to_column <- setNames(as.list(data_headers[1, ]), as.character(data_headers[2, ]))
+
+    # Number of important statements to be selected
+    p <- 6
+
+    # Define the list of column names
+    bucket_columns <- c("Stability", "Development", "Relationship", "Benefit", "Vision", "Competence")
+
+    # Select columns based on the predefined list
+    bucket <- data %>% select(all_of(bucket_columns))
+
+    # Select all columns from the consumer dataframe that contain "TB" in their names and assign them to the variable TB
+    TB <- data %>% select(contains("TB"))
+
+    # Initialize a matrix with 37 rows and 6 columns, filled with NA values
+    coef <- matrix(NA, ncol = 6, nrow = 37)
+
+    # Initialize an empty list to store the predictors for each bucket column
+    bucket_predictors <- list()
+
+    # Loop over each of the 6 columns
+    for (i in 1:6) {
+      # Extract the i-th column from 'bucket' as a matrix and assign it to 'y'
+      y <- as.matrix(pull(bucket[, i]))
+
+      # Convert 'TB' dataframe to a matrix and assign it to 'x'
+      x <- as.matrix(TB)
+
+      # Perform best subset regression using 'x' as predictors and 'y' as the response variable
+      fit <- regsubsets(x, y, nbest = 1, nvmax = p)
+
+      # Summarize the regression subsets
+      fit_sum <- summary(fit)
+
+      # Store the coefficients of the best model in the i-th column of 'coef' matrix
+      coef[, i] <- fit_sum$outmat[p, ]
+
+      # Print the predictors used in the best model
+      predictors <- names(which(fit_sum$outmat[p, ] == "*"))
+
+      # Append the predictors to the bucket_predictors list
+      bucket_predictors[[bucket_columns[i]]] <- predictors
+    }
+
+    # Create the desired output format as model
+    model_str <- sapply(names(bucket_predictors), function(col) {
+      paste(col, "~", paste(bucket_predictors[[col]], collapse = "+"))
+    })
+
+    # Prepend the Trust x and y to model_str
+    model_str <- c("Trust ~ Stability + Development + Relationship + Benefit + Vision + Competence", model_str)
+
+    # Fit the model using sem() function
+    fit <- sem(model_str, data = data)
+    fit_summary <- summary(fit, standardized = TRUE, fit.measures = TRUE, rsquare = TRUE)
 
-  # Create data frame of predictor names and their importance
-  results <- data.frame(Predictor = names(calc_relaimpo$lmg), Importance = calc_relaimpo$lmg)
+    # Make it percentages
+    output <- fit_summary$pe[fit_summary$pe$op == "~", c("lhs", "rhs", "std.all")]
 
-  # Save results to CSV file
-  write.csv(results, file = csv_file, row.names = FALSE)
+    # Define the function to convert std.all to percentages
+    convert_to_percentage <- function(df) {
+      df %>%
+        group_by(lhs) %>%
+        mutate(abs_std = abs(std.all),
+              sum_abs_std = sum(abs_std),
+              percent_std = (abs_std / sum_abs_std) * 100) %>%
+        select(-abs_std, -sum_abs_std) %>%
+        ungroup()
+    }
+
+    # Convert the estimates to percentages
+    percentage_output <- convert_to_percentage(output)
+
+    # Extract TB column names
+    tb_column_names <- colnames(TB)
+
+    # Convert std.all to a wide format dataframe
+    percentage_output_wide <- percentage_output %>%
+      pivot_wider(names_from = lhs, values_from = percent_std) %>%
+      rename_with(~ gsub("std.all\\.", "", .), starts_with("std.all"))
+
+    # Create a new dataframe with TB columns and percentage estimates
+    result_df <- data.frame(TB = tb_column_names)
+
+    # Merge the result_df with percentage_estimates_wide
+    result_df <- left_join(result_df, percentage_output_wide, by = c("TB" = "rhs"))
+
+    # Fill NA values with 0 to ensure proper representation
+    result_df[is.na(result_df)] <- 0
+
+    # Add corresponding messages of TB as a new column
+    result_df$Message <- sapply(result_df$TB, function(tb_col) question_to_column[[tb_col]])
+
+    # Convert 'TB' column to a factor with the correct order
+    result_df$TB <- factor(result_df$TB, levels = paste0("TB", 1:37))
+
+    # Exclude 'est' and 'Trust' columns and merge rows by 'TB'
+    result_df <- result_df %>%
+      select(-std.all, -Trust) %>%
+      group_by(TB) %>%
+      summarise(across(everything(), ~ if(is.numeric(.)) sum(., na.rm = TRUE) else first(.))) %>%
+      arrange(TB)
+
+    # Reorder columns to have Message as the second column
+    result_df <- result_df %>%
+      select(TB, Message, everything())
+
+    # Open the output text file in append mode to add this model's output
+    file_conn <- file(output_text_file, open = "a")
+
+    # Capture output to include in the text file
+    full_output <- capture.output({
+      print("Trust Builder Analysis:\n")
+      print("Data header mapping:\n")
+      print(question_to_column)
+      print("Buckets:\n")
+      print(bucket)
+      print("Messages:\n")
+      print(TB)
+      print("Coefficients matrix (coef:\n")
+      print(coef)
+      print("Model:\n")
+      cat(model_str, sep = "\n")
+      print("Fit summary:\n")
+      print(fit_summary)
+      print("Output:\n")
+      print(output)
+      print("Output in percentage (%):\n")
+      print(percentage_output)
+      print("result_df:\n")
+      print(result_df)
+    })
+    # Write output to text file
+    writeLines(full_output, file_conn)
+    close(file_conn)
+
+    # Create data frame of predictor names and their importance
+    results <- data.frame(result_df)
+
+    # Save results to CSV file
+    write.csv(results, file = csv_file, row.names = FALSE)
+  }, error = function(e) {
+    log_message(paste("Error in trust_builder_analysis:", e$message), output_text_file)
+  })
 }
 
 # Read command-line arguments
@@ -40,53 +205,83 @@ csv_output_path_nps <- args[4]
 csv_output_path_loyalty <- args[5]
 csv_output_path_consideration <- args[6]
 csv_output_path_satisfaction <- args[7]
-nps_present <- as.logical(tolower(args[8]))  # Expecting "TRUE" or "FALSE" as the argument
-loyalty_present <- as.logical(tolower(args[9]))
-consideration_present <- as.logical(tolower(args[10]))
-satisfaction_present <- as.logical(tolower(args[11]))
+csv_output_path_trustbuilder <- args[8]
+nps_present <- as.logical(tolower(args[9]))  # Expecting "TRUE" or "FALSE" as the argument
+loyalty_present <- as.logical(tolower(args[10]))
+consideration_present <- as.logical(tolower(args[11]))
+satisfaction_present <- as.logical(tolower(args[12]))
+trustbuilder_present <- as.logical(tolower(args[13]))
+
+# Log the starting of the script
+log_message("Starting Trust Driver and Builder Analysis Script.", output_text_file)
 
-# Load the dataset (CSV or Excel)
-data <- NULL
+########## Trust Driver Analysis ######################
+
+# Load the trust driver dataset (CSV or Excel)
+data_driver <- NULL
 if (grepl(".xlsx", input_file)) {
-  data <- read_excel(input_file)
-} else if (grepl(".csv", input_file)) {
-  data <- read_csv(input_file)
+  data_driver <- read_excel(input_file, sheet = "Driver")
 }
 
 # Process the Trust model
-process_model(Trust ~ Stability + Development + Relationship + Benefit + Vision + Competence, 
-              data,
-              output_text_file,
-              csv_output_path_trust)
+trust_driver_analysis(
+  Trust ~ Stability + Development + Relationship + Benefit + Vision + Competence, 
+  data_driver,
+  output_text_file,
+  csv_output_path_trust)
 
 # Conditionally process the NPS model
 if (nps_present) {
-  process_model(NPS ~ Stability + Development + Relationship + Benefit + Vision + Competence, 
-                data,
-                output_text_file,
-                csv_output_path_nps)
+  trust_driver_analysis(
+    NPS ~ Stability + Development + Relationship + Benefit + Vision + Competence, 
+    data_driver,
+    output_text_file,
+    csv_output_path_nps)
 }
 
 # Conditionally process the Loyalty model
 if (loyalty_present) {
-  process_model(Loyalty ~ Stability + Development + Relationship + Benefit + Vision + Competence, 
-                data,
-                output_text_file,
-                csv_output_path_loyalty)
+  trust_driver_analysis(
+    Loyalty ~ Stability + Development + Relationship + Benefit + Vision + Competence, 
+    data_driver,
+    output_text_file,
+    csv_output_path_loyalty)
 }
 
 # Conditionally process the Consideration model
 if (consideration_present) {
-  process_model(Consideration ~ Stability + Development + Relationship + Benefit + Vision + Competence, 
-                data,
-                output_text_file,
-                csv_output_path_consideration)
+  trust_driver_analysis(
+    Consideration ~ Stability + Development + Relationship + Benefit + Vision + Competence, 
+    data_driver,
+    output_text_file,
+    csv_output_path_consideration)
 }
 
 # Conditionally process the Satisfaction model
 if (satisfaction_present) {
-  process_model(Satisfaction ~ Stability + Development + Relationship + Benefit + Vision + Competence, 
-                data,
-                output_text_file,
-                csv_output_path_satisfaction)
-}
+  trust_driver_analysis(
+    Satisfaction ~ Stability + Development + Relationship + Benefit + Vision + Competence, 
+    data_driver,
+    output_text_file,
+    csv_output_path_satisfaction)
+}
+
+########## Trust Builder Analysis ######################
+
+if (trustbuilder_present) {
+  data_builder <- NULL
+
+  if (grepl(".xlsx", input_file)) {
+    # Read the first two rows as header mapping
+    data_builder_headers <- read_excel(input_file, sheet = "Builder", n_max = 2)
+    # Read the rest of the data, skipping the first two rows as datapoints
+    data_builder_rows <- read_excel(input_file, sheet = "Builder", skip = 2)
+  }
+
+  # Process the Builder model
+  trust_builder_analysis(data_builder_rows, data_builder_headers, output_text_file, csv_output_path_trustbuilder)
+
+}
+
+# Log the ending of the script
+log_message("Trust Driver and Builder Analysis Script Completed.", output_text_file)