private Boolean EvaluateFilter(Object key, Boolean filter)
{
if (KeyFilter == null && CompoundFilter == null)
{
return(true);
}
if (!filter)
{
return(true);
}
if (KeyFilter != null && CompoundFilter != null)
{
return(KeyFilter.Evaluate((String)key) && CompoundFilter.Evaluate((String)key));
}
if (KeyFilter != null)
{
return(KeyFilter.Evaluate((String)key));
}
if (CompoundFilter != null)
{
return(CompoundFilter.Evaluate((String)key));
}
return(false);
}
static void Encode(BinaryWriter writer, KeyFilter o)
{
EncodeID(writer, typeof(KeyFilter));
for (int i = 0; i < 101; i++)
{
writer.Write(o[i]);
}
}
public KeyFilterViewer(KeyFilter filter)
{
InitializeComponent();
_filter = filter;
for (int i = 0; i < 101; i++)
{
Grid.SetColor(LaunchpadGrid.SignalToGrid(i), GetColor(_filter[i]));
}
}
public void DumpCacheKeys()
{
try
{
if (!ValidateParameters())
{
return;
}
CacheConnectionOptions cacheParams = new CacheConnectionOptions();
ICache cache = CacheManager.GetCache(Name.ToLower(), cacheParams);
//cache.ExceptionsEnabled = true;
OutputProvider.WriteLine("Cache count: " + cache.Count);
IDictionaryEnumerator keys = (IDictionaryEnumerator)cache.GetEnumerator();
if (keys != null)
{
long index = 0;
bool checkFilter = (KeyFilter != "");
KeyFilter = KeyFilter.Trim();
while (keys.MoveNext())
{
if ((KeyCount > 0) && (index >= KeyCount))
{
break;
}
if (checkFilter == true)
{
string tmpKey = (string)keys.Key;
if (tmpKey.Contains(KeyFilter) == true)
{
OutputProvider.WriteLine(tmpKey);
}
}
else
{
OutputProvider.WriteLine(keys.Key);
}
index++;
} //end while
} //end if
cache.Dispose();
} //end try block
catch (Exception e)
{
OutputProvider.WriteErrorLine("Error: " + e.Message);
OutputProvider.WriteErrorLine(e.ToString());
}
OutputProvider.WriteLine(Environment.NewLine);
}
private EuGatewayService CreateGatewayServiceAndDependencies(IGatewayHttpClient httpClient)
{
_keysRepository = new TemporaryExposureKeyRepository(_dbContext, _countryRepository, _temporaryExposureKeyRepositoryLogger.Object);
var signatureServiceMock = new Mock <ISignatureService>(MockBehavior.Strict);
var webContextReader = new GatewayWebContextReader(_autoMapper, _loggerGatewayWebContextReader.Object);
var epochConverter = new EpochConverter();
var keyValidator = new KeyValidator(epochConverter);
var exposureKeyMapper = new ExposureKeyMapper(_epochConverter);
var keyFilterLoggerMock = new Mock <ILogger <KeyFilter> >(MockBehavior.Loose);
var keyFilter = new KeyFilter(_autoMapper, keyValidator, exposureKeyMapper, keyFilterLoggerMock.Object, _keysRepository);
var storeServiceLoggerMock = new Mock <ILogger <EFGSKeyStoreService> >();
var riskCalculator = new RiskCalculator();
var dsosDecoder = new DaysSinceOnsetOfSymptomsDecoder();
var addTemporaryExposureKeyService = new Mock <IAddTemporaryExposureKeyService>(MockBehavior.Strict);
addTemporaryExposureKeyService
.Setup(x => x.FilterDuplicateKeysAsync(It.IsAny <List <TemporaryExposureKey> >()))
.ReturnsAsync((List <TemporaryExposureKey> argument) =>
{
return(argument);
});
var storeService = new EFGSKeyStoreService(keyFilter, _keysRepository, storeServiceLoggerMock.Object, riskCalculator, epochConverter, dsosDecoder, addTemporaryExposureKeyService.Object);
var gatewayServiceLoggerMock = new Mock <ILogger <EuGatewayService> >(MockBehavior.Loose);
return(CreateGatewayService(
_keysRepository,
signatureServiceMock.Object,
_autoMapper,
httpClient,
keyFilter,
webContextReader,
storeService,
gatewayServiceLoggerMock.Object,
epochConverter,
_config
));
}
void Unloaded(object sender, VisualTreeAttachmentEventArgs e) => _filter = null;
static KeyGrabber()
{
_filter = new KeyFilter();
}
static KeyGrabber()
{
_filter = new KeyFilter();
}
public Predicate <STBLXMLEntry> GetFilterPredicate()
{
string keyFilterLower = KeyFilter?.ToLower();
Regex identifierFilterRegex = null;
if (IdentifierFilterUseRegex)
{
identifierFilterRegex = new Regex(IdentifierFilter, RegexOptions.Multiline | (IdentifierFilterMatchCase ? RegexOptions.None : RegexOptions.IgnoreCase));
}
Regex textFilterRegex = null;
if (TextFilterUseRegex)
{
textFilterRegex = new Regex(TextFilter, RegexOptions.Multiline | (TextFilterMatchCase ? RegexOptions.None : RegexOptions.IgnoreCase));
}
return(delegate(STBLXMLEntry entry) {
if (KeyFilter != null)
{
string itemKeyDecimal = entry.Key.ToString();
string itemKeyHexadecimal = "0x" + entry.Key.ToString("x");
if (!itemKeyDecimal.Contains(keyFilterLower) && !itemKeyHexadecimal.Contains(keyFilterLower))
{
return true;
}
}
if (IdentifierFilter != null)
{
if (!IdentifierFilterUseRegex || identifierFilterRegex == null)
{
if (entry.Identifier.IndexOf(IdentifierFilter, IdentifierFilterMatchCase ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase) < 0)
{
return true;
}
}
else
{
if (!identifierFilterRegex.IsMatch(entry.Identifier))
{
return true;
}
}
}
if (TextFilter != null)
{
foreach (STBL.Languages languague in STBL.GetAllLanguages())
{
string languageText = entry.GetText(languague);
if (languageText == null)
{
continue;
}
if (!TextFilterUseRegex || textFilterRegex == null)
{
if (languageText.IndexOf(TextFilter, TextFilterMatchCase ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase) < 0)
{
return true;
}
}
else
{
if (!textFilterRegex.IsMatch(languageText))
{
return true;
}
}
}
}
if (UntranslatedFilter != null)
{
try {
STBL.Languages untranslatedFilterLanguague = STBL.GetLanguage((int)UntranslatedFilter);
if (entry.GetText(untranslatedFilterLanguague) != null)
{
return true;
}
} catch { }
}
return false;
});
}
