/// <summary> /// This function processes special anonymization rules that require filters /// </summary> /// <param name="rule">Anonymization rule to be processed</param> /// <param name="value">The value to be anonymized</param> /// <param name="filterVariableValue">The variabele value that has to satisfy the filter condition</param> /// <returns>anonymized value</returns> /// <remarks> /// This functions checks if a value or its context is filtered. If it is, the value is anonymized /// </remarks> public string ProcessFilter(AnonymizeRule rule, string value, string filterVariableValue) { string result = ""; if (rule.IsFiltered && filterVariableValue != null) { //example rule: file;header;Empty;header3;<;20 var compareresult = filterVariableValue.CompareTo(rule.FilterValue); if (rule.FilterOperator == "<" && rule.Method == AnonymizeRule.MethodType.Empty) { result = value; StringBuilder sb = new StringBuilder(); sb.AppendFormat("Filter rule {0} was correct (filterVariableValue={1}). Value {2} can be anonymized" , rule.Filter, filterVariableValue, value); Console.WriteLine(sb.ToString()); if (compareresult < 0) { Console.WriteLine("and was emptied"); result = ""; } else { Console.WriteLine("but wasn't because it didn't satisfy the filter condition!"); } } } else { Console.WriteLine("Filter rule {0} was incorrect (filterVariableValue={1}). Value {2} was not anonymized!" , rule.Filter, filterVariableValue, value); } return(result); }
public bool IsFiltered(AnonymizeRule rule, string value) { var compareresult = value.CompareTo(rule.FilterValue); if (!rule.IsFiltered) { return(false); } if (rule.FilterOperator.Equals("!=")) { return(compareresult != 0); } if (rule.FilterOperator.Equals("=")) { return(compareresult == 0); } if (rule.FilterOperator.Equals("<")) { return(compareresult < 0); } if (rule.FilterOperator.Equals(">")) { return(compareresult > 0); } return(false); }
/// <summary> /// This method processes a single rule in the anonymization riles file, then adds it to the _AnonymizerRules list. /// This method is a hook for derived classes to implement their own method and extend the basic handling of this class. see class /// Core.XMLRecords.Anonymization.AnonymizerXML for an example /// </summary> /// <param name="fields">The fields that have been extracted from the line to be processed in the rules file</param> protected virtual void ProcessRule(string[] fields) { if (fields[2].ToLower().IndexOf(fnIndicator.ToLower()) >= 0) { _anonymizerRulesFilename.Add(fields[1]); } else { AnonymizeRule rule = new AnonymizeRule(); rule.Location = fields[1]; rule.Method = AnonymizeRule.getMethod(fields[2]); //Add filter elements if they are present if (fields.Length > 3) { rule.FilterLocation = fields[3]; } if (fields.Length > 4) { rule.FilterOperator = fields[4]; } if (fields.Length > 5) { rule.FilterValue = fields[5]; } _AnonymizerRules.Add(rule); } }