R/import_gesis_file.R

In antaldaniel/surveyreader: Data cleaning and integration for survey files

#' Import a GESIS file
#'
#' @param filename Temporarily defaults to \code{"ZA6694_v1-1-0.sav"}
#' @param follow_suggestions Will execute
#' @param see_log  \code{TRUE} which will print messages to the screen.
#' @param create_log  It will create log files in the sr_logs director.
#' @param my_treshold  Can be \code{WARN}, \code{INFO}, \code{ERROR}.
#' @param log_prefix Defaults to \code{NA}, in which case a
#' new one will be assigned to the logs (if they are requested.) The
#' log_prefix can be directly assigned.
#' @param log_id Defaults to \code{NA}, in which case a
#' new one will be assigned to the logs (if they are requested.) The
#' log_prefix can be directly assigned.
#' @importFrom dplyr mutate mutate_at mutate_if select filter one_of vars
#' @importFrom futile.logger flog.threshold flog.appender flog.remove
#' @importFrom futile.logger flog.info flog.warn flog.error WARN INFO
#' @importFrom futile.logger appender.file
#' @importFrom haven read_spss as_factor zap_labels
#' @examples
#' \dontrun{
#' import_gesis_file( follow_suggestions = FALSE,
#'                    see_log = TRUE,
#'                    create_log = TRUE,
#'                    my_treshold = INFO)
#' }
#' @export


import_gesis_file <- function( filename = "ZA6694_v1-1-0.sav",
                               follow_suggestions = TRUE,
                               see_log = TRUE,
                               create_log = TRUE,
                               my_treshold = futile.logger::WARN,
                               log_prefix = NA,
                               log_id = NA
                               ) {
  vars <- appender.file <- WARN <- INFO <- funs <- . <- NULL

  #my_treshold = futile.logger::INFO
  treshold <- futile.logger::flog.threshold(my_treshold)

  if (create_log == TRUE) {

    if (! file.exists("sr_logs")) {
      dir.create(file.path(paste0(getwd(), "/sr_logs")))
    }
    if (is.na(log_prefix)) {
      log_prefix <- paste0("sr_logs/", format(Sys.time(),
                                              "%Y_%b_%d_ %H_%M"))

    }
    if (is.na(log_id)) log_id <- "_gesis_import_"
    info <- futile.logger::flog.appender(
      futile.logger::appender.file(paste0(log_prefix, log_id, "_info.log")), name="info")
    warning <- futile.logger::flog.appender(
      futile.logger::appender.file(paste0(log_prefix, log_id, "_warning.log")), name="warning")
    error <- futile.logger::flog.appender(
      futile.logger::appender.file(paste0(log_prefix, log_id, "_error.log")), name="error")
  }

  read_spss_file <- filename

  #df <- eb_sample
  df <- haven::read_spss( read_spss_file )
  read_message <- paste0("Read ", read_spss_file)
  if (see_log)    futile.logger::flog.info(read_message)
  if (create_log) futile.logger::flog.info(read_message, name  ="info")

  m <- analyze_gesis_file(gesis_file = df, my_treshold = my_treshold,
                          log_prefix = log_prefix, log_id = log_id)

  if ( length(names(df)) == length(m$suggested_name)) {
    names(df) <- m$suggested_name
    if (see_log)    futile.logger::flog.info("Renaming variables following the suggested file names.")
    if (create_log) futile.logger::flog.info("Renaming variables following the suggested file names.", name  ="info")
  } else {
    naming_error_log <- "The length of metadata file and the data file do not match."
    if (see_log)    futile.logger::flog.error("Renaming variables following the suggested file names.")
    if (create_log) futile.logger::flog.error("Renaming variables following the suggested file names.", name  ="error")
    stop(naming_error_log)
  }

  class_df <- vapply( df, class, character(1))
  labelled_vars <- names(df)[which(class_df == 'labelled')]
  numeric_vars <-  names(df)[which(class_df == 'numeric')]

  if (see_log)    futile.logger::flog.info("Converting from labelled to factor class.")
  if (create_log) futile.logger::flog.info("Converting from labelled to factor class.", name  ="info")


  if ( length(labelled_vars)>0) {
    tryCatch({
      df <- df %>% dplyr::mutate_at ( dplyr::vars(dplyr::one_of(labelled_vars)),
                                      haven::as_factor )
    },
    error=function(cond) {
      labelled_vars_error <- paste0("Not successful -> labelled_vars, ", cond)
      warning(labelled_vars_error )
      futile.logger::flog.error(labelled_vars_error, name="error")
      futile.logger::flog.info(labelled_vars_error, name="info")
    },
    warning=function(cond) {
      labelled_vars_warning <- paste0("Warning -> labelled_vars, ", cond)
      futile.logger::flog.warn(labelled_vars_warning, name="warning")
      futile.logger::flog.info(labelled_vars_warning, name="info")
    },
    finally={
      labelled_vars_message <- paste0("Converted: ",
                                      length(labelled_vars),
                                      " labelled SPSS variables to factors.")
      if (see_log)  futile.logger::flog.info(labelled_vars_message)
      futile.logger::flog.info(labelled_vars_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: labelled factors.",
                             data = 'info')
  }

  if ( length(numeric_vars)>0) {
    tryCatch({
      df <- df %>% dplyr::mutate_at ( dplyr::vars(dplyr::one_of(numeric_vars)),
                                      haven::zap_labels )
    },
    error=function(cond) {
      numeric_vars_error <- paste0("Not successful -> removing labels from numeric variables, ", cond)
      warning(numeric_vars_error)
      futile.logger::flog.error(numeric_vars_error, name="error")
      futile.logger::flog.info(numeric_vars_error, name="info")
    },
    warning=function(cond) {
      numericvars_warning <- paste0("Warning -> removing labels from numeric variables, ", cond)
      futile.logger::flog.warn(numericvars_warning , name="warning")
      futile.logger::flog.info(numericvars_warning , name="info")
    },
    finally={
      numeric_vars_message <- paste0("Converted: ",
                                      length(numeric_vars),
                                      " labelled SPSS variables to numeric.")
      if (see_log)  futile.logger::flog.info(numeric_vars_message)
      futile.logger::flog.info(numeric_vars_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: labelled numeric vars.",
                             data = 'info')
  }

  if ( follow_suggestions == FALSE ) {
    return_message <- paste0("Returning a\n",
                             paste(class(df), collapse = " "),
                             " with ",
                             nrow(df), " observations in ",
                             ncol(df), " data and metadata columns.")
    if (see_log)    futile.logger::flog.info(return_message)
    if (create_log) futile.logger::flog.info(return_message, name  ="info")

    if (create_log)  {
      info <-    futile.logger::flog.remove("info")
      warning <- futile.logger::flog.remove("warn")
      error <-   futile.logger::flog.remove("error")
      return(df)
    }
    }

  ##Suggested conversions ----
  rescale_acceptable_3_vars <- m$suggested_name [ m$suggested_class == "rescale_acceptable_3"]
  if ( length(rescale_acceptable_3_vars)>0) {
    tryCatch({
      df <- mutate_at ( df,
                        dplyr::vars(one_of (rescale_acceptable_3_vars)),
                        funs(surveyreader::rescale_acceptable_3(
                          column =.,
                          na_labels = c("DK")) ))
    },
    error=function(cond) {
      rescale_acceptable_3_error <- paste0("Not successful -> rescale_acceptable_3_vars, ", cond)
      warning(rescale_acceptable_3_error )
      futile.logger::flog.error(rescale_acceptable_3_error, name="error")
      futile.logger::flog.info(rescale_acceptable_3_error, name="info")
    },
    warning=function(cond) {
      rescale_acceptable_3_warning <- paste0("Warning -> rescale_acceptable_3_vars, ", cond)
      futile.logger::flog.warn(rescale_acceptable_3_warning, name="warning")
      futile.logger::flog.info(rescale_acceptable_3_warning, name="info")
    },
    finally={
      rescale_acceptable_3_message <- paste0("Rescaled: ",
                                             length(rescale_acceptable_3_vars),
                                             " three-level acceptance level variables.")
      if (see_log)  futile.logger::flog.info(rescale_acceptable_3_message)
      futile.logger::flog.info(rescale_acceptable_3_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: three-level rescale_acceptable_3 variables.",
              data = 'info')
  }

  rescale_agreement_4_vars <- m$suggested_name [ m$suggested_class == "rescale_agreement_4"]
  if ( length(rescale_agreement_4_vars)>0) {
    tryCatch({
      df <- mutate_at ( df,
                        dplyr::vars(one_of (rescale_agreement_4_vars)),
                        funs(surveyreader::rescale_agreement_4(
                          column =.,
                          na_labels = c("DK")) ))
    },
    error=function(cond) {
      rescale_agreement_4_error <- paste0("Not successful -> rescale_agreement_4_vars, ", cond)
      warning(rescale_agreement_4_error )
      futile.logger::flog.error(rescale_agreement_4_error, name="error")
      futile.logger::flog.info(rescale_agreement_4_error, name="info")
    },
    warning=function(cond) {
      rescale_agreement_4_warning <- paste0("Warning -> rescale_agreement_4_vars, ", cond)
      futile.logger::flog.warn(rescale_agreement_4_warning, name="warning")
      futile.logger::flog.info(rescale_agreement_4_warning, name="info")
    },
    finally={
      rescale_agreement_4_message <- paste0("Rescaled: ",
                                            length(rescale_agreement_4_vars),
                                            " three-level time frequency variables.")
      if (see_log) futile.logger::flog.info(rescale_agreement_4_message)
      futile.logger::flog.info(rescale_agreement_4_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: four-level rescale_agreement_4 variables.",
              data = 'info')
  }
  ##Amount of things
  rescale_amount_3_vars <- m$suggested_name [ m$suggested_class == "rescale_amount_3"]
  if ( length(rescale_amount_3_vars)>0) {
    tryCatch({
      df <-mutate_at ( df,
                       dplyr::vars(dplyr::one_of(rescale_amount_3_vars)),
                       rescale_amount_3)
    },
    error=function(cond) {
      amount_3_vars_error <- paste0("Not successful -> rescale_amount_3_vars, ", cond)
      warning(amount_3_vars_error)
      futile.logger::flog.error(amount_3_vars_error, name="error")
      futile.logger::flog.info(amount_3_vars_error, name="info")
    },
    warning=function(cond) {
      amount_3_vars_warning <- paste0("Warning -> rescale_amount_3_vars, ", cond)
      futile.logger::flog.warn(amount_3_vars_warning, name="warning")
      futile.logger::flog.info(amount_3_vars_warning, name="info")
    },
    finally={
      amount_3_vars_message <- paste0("Rescaled: ",
                                      length(rescale_amount_3_vars),
                                      " three-level amount categorical variables.")
      if (see_log)  futile.logger::flog.info(amount_3_vars_message)
      futile.logger::flog.info(amount_3_vars_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: three-level amount_3_vars variables.",
                             data = 'info')
  }
  ##Attachment to country, EU, etc.
  rescale_attachment_4_vars <- m$suggested_name [ m$suggested_class == "rescale_attachment_4"]
  if ( length(rescale_attachment_4_vars)>0) {
    tryCatch({
      df <- mutate_at ( df,
                        dplyr::vars(dplyr::one_of (rescale_attachment_4_vars)),
                        funs(surveyreader::rescale_attachment_4(
                          column =.,
                          na_labels = c("DK")) ))
    },
    error=function(cond) {
      rescale_attachment_4_error <- paste0("Not successful -> rescale_attachment_4_vars, ", cond)
      warning(rescale_attachment_4_error )
      futile.logger::flog.error(rescale_attachment_4_error, name="error")
      futile.logger::flog.info(rescale_attachment_4_error, name="info")
    },
    warning=function(cond) {
      rescale_attachment_4_warning <- paste0("Warning -> rescale_attachment_4_vars, ", cond)
      futile.logger::flog.warn(rescale_attachment_4_warning, name="warning")
      futile.logger::flog.info(rescale_attachment_4_warning, name="info")
    },
    finally={
      rescale_attachment_4_message <- paste0("Rescaled: ",
                                             length(rescale_attachment_4_vars),
                                             " three-level acceptance level variables.")
      if (see_log)  futile.logger::flog.info(rescale_attachment_4_message)
      futile.logger::flog.info(rescale_attachment_4_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: four-level rescale_attachment_4 variables.",
              data = 'info')
  }
  ##Alphanumerically coded numbers
  rescale_alphanumeric_en_vars <- m$suggested_name [m$suggested_class == "rescale_alphanumeric_en"]
  if ( length(rescale_alphanumeric_en_vars)>0) {
    tryCatch({
      df <-mutate_at ( df,
                       dplyr::vars(dplyr::one_of(rescale_alphanumeric_en_vars)),
                       funs(rescale_alphanumeric_en(column =.)))
    },
    error=function(cond) {
      rescale_alphanumeric_en_error <- paste0("Not successful -> rescale_ralphanumeric_en, ", cond)
      warning(rescale_alphanumeric_en_error)
      futile.logger::flog.error(rescale_alphanumeric_en_error, name="error")
      futile.logger::flog.info(rescale_alphanumeric_en_error, name="info")
    },
    warning=function(cond) {
      rescale_alphanumeric_en_warning <- paste0("Warning -> rescale_ralphanumeric_en, ", cond)
      futile.logger::flog.warn(rescale_alphanumeric_en_warning, name="warning")
      futile.logger::flog.info(rescale_alphanumeric_en_warning, name="info")
    },
    finally={
      rescale_alphanumeric_en_message <- paste0("Rescaled: ", length(rescale_alphanumeric_en_vars),  " three-level time frequency variables.")
      if (see_log)  futile.logger::flog.info(rescale_alphanumeric_en_message)
      futile.logger::flog.info(rescale_alphanumeric_en_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: English rescale_alphanumeric_en variables.",
              data = 'info')
  }

  ##Rescale benefit or not benefit wars
  rescale_benefit_2_vars <- m$suggested_name [ m$suggested_class == "rescale_benefit_2"]
  if ( length(rescale_benefit_2_vars)>0) {
    tryCatch({
      df <- mutate_at ( df,
                        dplyr::vars(dplyr::one_of (rescale_benefit_2_vars)),
                        funs(surveyreader::rescale_benefit_2(
                          column =.,
                          na_labels = c("DK")) ))
    },
    error=function(cond) {
      rescale_benefit_2_error <- paste0("Not successful -> rescale_benefit_2_vars, ", cond)
      warning(rescale_benefit_2_error )
      futile.logger::flog.error(rescale_benefit_2_error, name="error")
      futile.logger::flog.info(rescale_benefit_2_error, name="info")
    },
    warning=function(cond) {
      rescale_benefit_2_warning <- paste0("Warning -> rescale_benefit_2_vars, ", cond)
      futile.logger::flog.warn(rescale_benefit_2_warning, name="warning")
      futile.logger::flog.info(rescale_benefit_2_warning, name="info")
    },
    finally={
      rescale_benefit_2_message <- paste0("Rescaled: ",
                                          length(rescale_benefit_2_vars),
                                          " three-level acceptance level variables.")
      if (see_log)  futile.logger::flog.info(rescale_benefit_2_message)
      futile.logger::flog.info(rescale_benefit_2_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: four-level rescale_benefit_2 variables.",
              data = 'info')
  }
  ##Rescale likely 4 variables
  rescale_likely_4_vars <- m$suggested_name [ m$suggested_class == "rescale_likely_4"]
  if ( length(rescale_likely_4_vars)>0) {
    tryCatch({
      df <-mutate_at ( df,
                       dplyr::vars(dplyr::one_of(rescale_likely_4_vars)),
                       rescale_likely_4)
    },
    error=function(cond) {
      likely_4_vars_error <- paste0("Not successful -> rescale_likely_4_vars, ", cond)
      warning(likely_4_vars_error)
      futile.logger::flog.error(likely_4_vars_error, name="error")
      futile.logger::flog.info(likely_4_vars_error, name="info")
    },
    warning=function(cond) {
      likely_4_vars_warning <- paste0("Warning -> rescale_likely_4_vars, ", cond)
      futile.logger::flog.warn(likely_4_vars_warning, name="warning")
      futile.logger::flog.info(likely_4_vars_warning, name="info")
    },
    finally={
      likely_4_vars_message <- paste0("Rescaled: ",
                                      length(rescale_likely_4_vars),
                                      " four-level likelihood categorical variables.")
      if (see_log)  futile.logger::flog.info(likely_4_vars_message)
      futile.logger::flog.info(likely_4_vars_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: four-level likely_4_vars variables.",
                             data = 'info')
  }
  ##Rescale difficulty of paying bills quesitons
  rescale_difficulty_vars <- m$suggested_name [ m$suggested_class == "rescale_difficulty"]
  if ( length(rescale_difficulty_vars)>0) {
    tryCatch({
      df <-mutate_at ( df,
                       dplyr::vars(dplyr::one_of(rescale_difficulty_vars)),
                       funs(rescale_difficulty(
                         column =.,
                         na_labels = "Refusal (SPONT.)")))
    },
    error=function(cond) {
      rescale_difficulty_error <- paste0("Not successful -> rescale_difficulty, ", cond)
      warning(rescale_difficulty_error )
      futile.logger::flog.error(rescale_difficulty_error, name="error")
      futile.logger::flog.info(rescale_difficulty_error, name="info")
    },
    warning=function(cond) {
      rescale_difficulty_warning <- paste0("Warning -> rescale_rdifficulty, ", cond)
      futile.logger::flog.warn(rescale_difficulty_warning, name="warning")
      futile.logger::flog.info(rescale_difficulty_warning, name="info")
    },
    finally={
      rescale_difficulty_message <- paste0("Rescaled: ",
                                           length(rescale_difficulty_vars),
                                           " difficulty of paying bills variables.")
      if (see_log)  futile.logger::flog.info(rescale_difficulty_message)
      futile.logger::flog.info(rescale_difficulty_message,
                name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: rescale difficulty of paying bills variables.", data = 'info')
  }

  rescale_time_frequency_3_vars <- m$suggested_name [ m$suggested_class == "rescale_time_frequency_3"]
  if ( length(rescale_time_frequency_3_vars)>0) {
    tryCatch({
      df <- mutate_at ( df,
                        dplyr::vars(dplyr::one_of( rescale_time_frequency_3_vars)),
                        surveyreader::rescale_time_frequency_3)
    },
    error=function(cond) {
      time_frequency_3_error <- paste0("Not successful -> rescale_time_frequency_3, ", cond)
      warning(time_frequency_3_error )
      futile.logger::flog.error(time_frequency_3_error, name="error")
      futile.logger::flog.info(time_frequency_3_error, name="info")
    },
    warning=function(cond) {
      time_frequency_3_warning <- paste0("Warning -> rescale_time_frequency_3, ", cond)
      futile.logger::flog.warn(time_frequency_3_warning, name="warning")
      futile.logger::flog.info(time_frequency_3_warning, name="info")
    },
    finally={
      time_frequency_3_message <- paste0("Rescaled: ", length(rescale_time_frequency_3_vars),  " three-level time frequency variables.")
      if (see_log)  futile.logger::flog.info(time_frequency_3_message)
      futile.logger::flog.info(time_frequency_3_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: three-level time frequency variables.",
              data = 'info')
  }

  ##Rescale intensity scales
  rescale_low_strong_4_vars <- m$suggested_name [ m$suggested_class == "rescale_low_strong_4"]
  if ( length(rescale_low_strong_4_vars)>0) {
    tryCatch({
      df <-mutate_at ( df,
                       dplyr::vars(dplyr::one_of(rescale_low_strong_4_vars)),
                       rescale_low_strong_4)
    },
    error=function(cond) {
      low_strong_4_vars_error <- paste0("Not successful -> rescale_low_strong_4_vars, ", cond)
      warning(low_strong_4_vars_error)
      futile.logger::flog.error(low_strong_4_vars_error, name="error")
      futile.logger::flog.info(low_strong_4_vars_error, name="info")
    },
    warning=function(cond) {
      low_strong_4_vars_warning <- paste0("Warning -> rescale_low_strong_4_vars, ", cond)
      futile.logger::flog.warn(low_strong_4_vars_warning, name="warning")
      futile.logger::flog.info(low_strong_4_vars_warning, name="info")
    },
    finally={
      low_strong_4_vars_message <- paste0("Rescaled: ",
                                          length(rescale_low_strong_4_vars),
                                          " four-level intensity categorical variables.")
      if (see_log)  futile.logger::flog.info(low_strong_4_vars_message)
      futile.logger::flog.info(low_strong_4_vars_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: four-level low_strong_4_vars variables.",
                             data = 'info')
  }
  ##keep only the numeric part of the data
  keep_numeric_vars <- m$suggested_name [ m$suggested_class == "keep_numeric"]
  if ( length(keep_numeric_vars )>0) {
    tryCatch({
      df <- mutate_at ( df,
                        dplyr::vars(dplyr::one_of( keep_numeric_vars )),
                        surveyreader::keep_numeric)
    },
    error=function(cond) {
      keep_numeric_error <- paste0("Not successful -> keep_numeric_vars, ", cond)
      warning(keep_numeric_error)
      futile.logger::flog.error(keep_numeric_error, name="error")
      futile.logger::flog.info(keep_numeric_error, name="info")
    },
    warning=function(cond) {
      keep_numeric_warning <- paste0("Warning -> keep_numeric_vars, ", cond)
      futile.logger::flog.warn(keep_numeric_warning, name="warning")
      futile.logger::flog.info(keep_numeric_warning, name="info")
    },
    finally={
      keep_numeric_message <- paste0("Kept only the number from ", length(keep_numeric_vars),  " variables.")
      if (see_log)  futile.logger::flog.info(keep_numeric_message )
      futile.logger::flog.info(keep_numeric_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: keep_numeric_vars variables.", data = 'info')
  }

  ##Numeric to character conversions
  rescale_num_to_chr_vars <-m$suggested_name [ m$suggested_class == "num_to_chr"]
  if ( length(rescale_num_to_chr_vars)>0) {
    tryCatch({
      df <-mutate_at ( df,
                       dplyr::vars(dplyr::one_of(rescale_num_to_chr_vars)),
                       as.character)
    },
    error=function(cond) {
      num_to_chr_error <- paste0("Not successful -> rescale_num_to_chr, ", cond)
      warning(num_to_chr_error)
      futile.logger::flog.error(num_to_chr_error, name="error")
      futile.logger::flog.info(num_to_chr_error, name="info")
    },
    warning=function(cond) {
      num_to_chr_warning <- paste0("Warning -> rescale_num_to_chr, ", cond)
      futile.logger::flog.warn(num_to_chr_warning, name="warning")
      futile.logger::flog.info(num_to_chr_warning, name="info")
    },
    finally={
      num_to_chr_message <- paste0("Rescaled: ", length(rescale_num_to_chr_vars),  " three-level time frequency variables.")
      if (see_log)  futile.logger::flog.info(num_to_chr_message)
      futile.logger::flog.info(num_to_chr_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: numeric to character num_to_chr variables.",
              data = 'info')
  }

  ##Satisfaction vars
  rescale_satisfaction_vars <- m$suggested_name [ m$suggested_class == "rescale_satisfaction"]
  if ( length(rescale_satisfaction_vars)>0) {
    tryCatch({
      df <-mutate_at ( df,
                       dplyr::vars(dplyr::one_of(rescale_satisfaction_vars)),
                       rescale_satisfaction)
    },
    error=function(cond) {
      satisfaction_vars_error <- paste0("Not successful -> rescale_satisfaction_vars, ", cond)
      warning(satisfaction_vars_error)
      futile.logger::flog.error(satisfaction_vars_error, name="error")
      futile.logger::flog.info(satisfaction_vars_error, name="info")
    },
    warning=function(cond) {
      satisfaction_vars_warning <- paste0("Warning -> rescale_satisfaction_vars, ", cond)
      futile.logger::flog.warn(satisfaction_vars_warning, name="warning")
      futile.logger::flog.info(satisfaction_vars_warning, name="info")
    },
    finally={
      satisfaction_vars_message <- paste0("Rescaled: ",
                                          length(rescale_satisfaction_vars),
                                          " four-level satisfaction categorical variables.")
      if (see_log)  futile.logger::flog.info(satisfaction_vars_message)
      futile.logger::flog.info(satisfaction_vars_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: four-level satisfaction_vars variables.",
              data = 'info')
  }

  ##Variations of yes-no questions
  rescale_yes_no_2_vars <- m$suggested_name [ m$suggested_class == "rescale_yes_no_2"]
  if ( length(rescale_yes_no_2_vars)>0) {
    tryCatch({
      df <-mutate_at ( df,
                       dplyr::vars(dplyr::one_of(rescale_yes_no_2_vars)),
                       rescale_yes_no_2)
    },
    error=function(cond) {
      yes_no_2_vars_error <- paste0("Not successful -> rescale_yes_no_2_vars, ", cond)
      warning(yes_no_2_vars_error)
      futile.logger::flog.error(yes_no_2_vars_error, name="error")
      futile.logger::flog.info(yes_no_2_vars_error, name="info")
    },
    warning=function(cond) {
      yes_no_2_vars_warning <- paste0("Warning -> rescale_yes_no_2_vars, ", cond)
      futile.logger::flog.warn(yes_no_2_vars_warning, name="warning")
      futile.logger::flog.info(yes_no_2_vars_warning, name="info")
    },
    finally={
      yes_no_2_vars_message <- paste0("Rescaled: ",
                                      length(rescale_yes_no_2_vars),
                                      " two-level yes-no categorical variables.")
      if (see_log)  futile.logger::flog.info(yes_no_2_vars_message)
      futile.logger::flog.info(yes_no_2_vars_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: two-level yes_no_2_vars variables.",
                             data = 'info')
  }

  rescale_yes_no_3_vars <- m$suggested_name [ m$suggested_class == "rescale_yes_no_3"]
  if ( length(rescale_yes_no_3_vars)>0) {
    tryCatch({
      df <-mutate_at ( df,
                       dplyr::vars(dplyr::one_of(rescale_yes_no_3_vars)),
                       rescale_yes_no_3)
    },
    error=function(cond) {
      yes_no_3_vars_error <- paste0("Not successful -> rescale_yes_no_3_vars, ", cond)
      warning(yes_no_3_vars_error)
      futile.logger::flog.error(yes_no_3_vars_error, name="error")
      futile.logger::flog.info(yes_no_3_vars_error, name="info")
    },
    warning=function(cond) {
      yes_no_3_vars_warning <- paste0("Warning -> rescale_yes_no_3_vars, ", cond)
      futile.logger::flog.warn(yes_no_3_vars_warning, name="warning")
      futile.logger::flog.info(yes_no_3_vars_warning, name="info")
    },
    finally={
      yes_no_3_vars_message <- paste0("Rescaled: ",
                                      length(rescale_yes_no_3_vars),
                                      " three-level yes-no categorical variables.")
      if (see_log)  futile.logger::flog.info(yes_no_3_vars_message)
      futile.logger::flog.info(yes_no_3_vars_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: three-level yes_no_3_vars variables.",
                             data = 'info')
  }

  rescale_yes_no_4_vars <- m$suggested_name [ m$suggested_class == "rescale_yes_no_4"]
  if ( length(rescale_yes_no_4_vars)>0) {
    tryCatch({
      df <-mutate_at ( df,
                       dplyr::vars(dplyr::one_of(rescale_yes_no_4_vars)),
                       rescale_yes_no_4)
    },
    error=function(cond) {
      yes_no_4_vars_error <- paste0("Not successful -> rescale_yes_no_4_vars, ", cond)
      warning(yes_no_4_vars_error)
      futile.logger::flog.error(yes_no_4_vars_error, name="error")
      futile.logger::flog.info(yes_no_4_vars_error, name="info")
    },
    warning=function(cond) {
      yes_no_4_vars_warning <- paste0("Warning -> rescale_yes_no_4_vars, ", cond)
      futile.logger::flog.warn(yes_no_4_vars_warning, name="warning")
      futile.logger::flog.info(yes_no_4_vars_warning, name="info")
    },
    finally={
      yes_no_4_vars_message <- paste0("Rescaled: ",
                                      length(rescale_yes_no_4_vars),
                                      " four-level yes-no categorical variables.")
      if (see_log)  futile.logger::flog.info(yes_no_4_vars_message)
      futile.logger::flog.info(yes_no_4_vars_message, name = "info")
    })
  } else {
    futile.logger::flog.info("Not found in file: four-level yes_no_4_vars variables.",
                             data = 'info')
  }

  df <- dplyr::mutate_if  (df, is.numeric, as.numeric )
  df <- dplyr::mutate_if  (df, is.character, as.character)

  if (create_log)  {
    info <-    futile.logger::flog.remove("info")
    warning <- futile.logger::flog.remove("warn")
    error <-   futile.logger::flog.remove("error")
  }

 return(df)
}