public EuGatewayService(ITemporaryExposureKeyRepository tempKeyRepository,
ISignatureService signatureService,
IEncodingService encodingService,
IKeyFilter keyFilter,
IGatewayWebContextReader gatewayWebContextReader,
IMapper mapper,
ILogger <EuGatewayService> logger,
EuGatewayConfig euGatewayConfig,
ISettingsService settingsService,
IEpochConverter epochConverter,
IGatewayHttpClient gatewayHttpClient,
IEFGSKeyStoreService storeService
)
{
_signatureService = signatureService;
_tempKeyRepository = tempKeyRepository;
_encodingService = encodingService;
_keyFilter = keyFilter;
_webContextReader = gatewayWebContextReader;
_mapper = mapper;
_logger = logger;
_euGatewayConfig = euGatewayConfig;
_settingsService = settingsService;
_epochConverter = epochConverter;
_gatewayHttpClient = gatewayHttpClient;
_storeService = storeService;
}
private void GetCombinedKeysFromEveryType(string tag, HashVector finalResult)
{
if (_indexMap == null)
{
return;
}
IDictionaryEnumerator typeEnumerator;
lock (_indexMap.SyncRoot)
{
typeEnumerator = _indexMap.GetEnumerator();
}
while (typeEnumerator.MoveNext())
{
AttributeIndex index = typeEnumerator.Value as AttributeIndex;
IIndexStore store = index.GetStore("$Tag$");
if (store != null)
{
IKeyFilter keyFilter = _cache != null?_cache.GetBucketFilter() : null;
IKeyFilter compoundFilter = _cache != null?_cache.GetCompoundFilter() : null;
IQueryResult result = new ListQueryResult(keyFilter, compoundFilter);
store.GetData(tag.ToLower(), ComparisonType.EQUALS, result, CollectionOperation.Union);
foreach (string key in result)
{
finalResult[key] = null;
}
}
}
}
internal static void AddKeyFilter(IKeyFilter value)
{
lock (key_filters)
{
key_filters.Add(value);
}
}
private EuGatewayService CreateGatewayService(
TemporaryExposureKeyRepository keysRepository,
ISignatureService signatureService,
IMapper autoMapper,
IGatewayHttpClient gateWayHttpClient,
IKeyFilter keyFilter,
IGatewayWebContextReader webContextReader,
IEFGSKeyStoreService storeService,
ILogger <EuGatewayService> logger,
EuGatewayConfig config)
{
var encodingService = new EncodingService();
var epochConverter = new EpochConverter();
var gatewaySyncStateSettingsDao = new GatewaySyncStateSettingsDao(new SettingRepository(_dbContext));
var settingsService = new SettingsService(gatewaySyncStateSettingsDao);
return(new EuGatewayService(
keysRepository,
signatureService,
encodingService,
keyFilter,
webContextReader,
autoMapper,
logger,
config,
settingsService,
epochConverter,
gateWayHttpClient,
storeService));
}
public MapperTask(IMapper mapper, MapReduceInput input, IKeyFilter filter, MapReduceTask prnt)
{
this.mapper = mapper;
this.parent = prnt;
this.inputProvider = input;
this.keyFilter = filter;
}
internal static bool FilterKey(KeyFilterData key)
{
lock (key_filters) {
for (int i = 0; i < key_filters.Count; i++)
{
IKeyFilter filter = (IKeyFilter)key_filters[i];
if (filter.PreFilterKey(key))
{
return(true);
}
}
}
return(false);
}
public void RemoveKeyDuplicates_ShouldOnlyWorkOnKeysCreatedUpTo14DaysAgo()
{
var options = new DbContextOptionsBuilder <DigNDB_SmittestopContext>()
.UseInMemoryDatabase(nameof(EuGatewayServiceUploadTest))
.Options;
var dbContext = new DigNDB_SmittestopContext(options);
dbContext.Database.EnsureDeleted();
var translationsRepositoryMock = new Mock <IGenericRepository <Translation> >(MockBehavior.Strict);
var originSpecificSettings = new AppSettingsConfig()
{
OriginCountryCode = "dk"
};
var countryRepository = new CountryRepository(dbContext, translationsRepositoryMock.Object, originSpecificSettings);
var keysRepository = new TemporaryExposureKeyRepository(dbContext, countryRepository);
_keyFilter = new KeyFilter(_keyMapper, _keyValidator.Object, new ExposureKeyMapper(), _logger.Object, keysRepository);
var rollingStartNumberNewerThan14Days = DateTimeOffset.Now.Subtract(new TimeSpan(DaysOffset - 1, 0, 0, 0)).ToUnixTimeSeconds();
var rollingStartNumberOlderThan14Days = DateTimeOffset.Now.Subtract(new TimeSpan(DaysOffset + 3, 0, 0, 0)).ToUnixTimeSeconds();
var origin = new Country {
Id = 1
};
var keysNewerThan14Days = new List <TemporaryExposureKey>
{
new TemporaryExposureKey {
Id = Guid.NewGuid(), RollingStartNumber = rollingStartNumberNewerThan14Days, Origin = origin, KeyData = new byte[] { 1 }
},
};
var keysOlderThan14Days = new List <TemporaryExposureKey>
{
new TemporaryExposureKey {
Id = Guid.NewGuid(), RollingStartNumber = rollingStartNumberOlderThan14Days, Origin = origin, KeyData = new byte[] { 2 }
},
new TemporaryExposureKey {
Id = Guid.NewGuid(), RollingStartNumber = rollingStartNumberOlderThan14Days, Origin = origin, KeyData = new byte[] { 3 }
},
};
var keyList = keysNewerThan14Days.Concat(keysOlderThan14Days).ToList();
dbContext.TemporaryExposureKey.AddRange(keyList);
dbContext.SaveChanges();
var filteredList = _keyFilter.RemoveKeyDuplicatesAsync(keyList).Result;
filteredList.Count.Should().Be(keysOlderThan14Days.Count);
}
private void GetCombinedKeysFromEveryType(string tag, HashVector finalResult, CancellationToken token, bool wildCardSupport = false)
{
if (_indexMap == null)
{
return;
}
IDictionaryEnumerator typeEnumerator;
lock (_indexMap.SyncRoot)
{
typeEnumerator = _indexMap.GetEnumerator();
}
while (typeEnumerator.MoveNext())
{
if (token != null && token.IsCancellationRequested)
{
throw new OperationCanceledException(ExceptionsResource.OperationFailed);
}
AttributeIndex index = typeEnumerator.Value as AttributeIndex;
IIndexStore store = index.GetStore("$Tag$");
if (store != null)
{
IKeyFilter keyFilter = _cache != null?_cache.GetBucketFilter() : null;
IKeyFilter compoundFilter = _cache != null?_cache.GetCompoundFilter() : null;
IQueryResult result = new ListQueryResult(keyFilter, compoundFilter);
if (wildCardSupport)
{
store.GetData(tag.ToLower(), ComparisonType.LIKE, result, CollectionOperation.Union, token);
}
else
{
store.GetData(tag.ToLower(), ComparisonType.EQUALS, result, CollectionOperation.Union, token);
}
foreach (string key in result)
{
finalResult[key] = null;
}
}
}
}
public EFGSKeyStoreService(IGatewayWebContextReader reader,
IKeyFilter filter,
ITemporaryExposureKeyRepository repository,
ILogger <EFGSKeyStoreService> logger,
IRiskCalculator riskCalculator,
IEpochConverter epochConverter,
IDaysSinceOnsetOfSymptomsDecoder daysSinceOnsetOfSymptomsDecoder)
{
_webContextReader = reader;
_keyFilter = filter;
_tempKeyRepository = repository;
_logger = logger;
_riskCalculator = riskCalculator;
_epochConverter = epochConverter;
_daysSinceOnsetOfSymptomsDecoder = daysSinceOnsetOfSymptomsDecoder;
}
public EFGSKeyStoreService(IKeyFilter filter,
ITemporaryExposureKeyRepository repository,
ILogger <EFGSKeyStoreService> logger,
IRiskCalculator riskCalculator,
IEpochConverter epochConverter,
IDaysSinceOnsetOfSymptomsDecoder daysSinceOnsetOfSymptomsDecoder,
IAddTemporaryExposureKeyService addTemporaryExposureKeyService)
{
_addTemporaryExposureKeyService = addTemporaryExposureKeyService;
_keyFilter = filter;
_tempKeyRepository = repository;
_logger = logger;
_riskCalculator = riskCalculator;
_epochConverter = epochConverter;
_daysSinceOnsetOfSymptomsDecoder = daysSinceOnsetOfSymptomsDecoder;
}
public void Init()
{
_exposureKeyMock = new ExposureKeyMock();
_countryFactory = new CountryMockFactory();
_mockServices = new SetupMockedServices();
_keyValidator = new Mock <IKeyValidator>(MockBehavior.Strict);
_logger = new Mock <ILogger <KeyFilter> >();
_repository = new Mock <ITemporaryExposureKeyRepository>(MockBehavior.Strict);
_countryRepository = new Mock <ICountryRepository>(MockBehavior.Strict);
_mockServices.SetupMapperAndCountryRepositoryMock(_countryRepository);
_keyMapper = _mockServices.CreateAutoMapperWithDependencies(_countryRepository.Object);
_mockServices.SetupKeyValidatorMock(_keyValidator);
_mockServices.SetupTemopraryExposureKeyRepositoryMock(_repository);
var mapper = new ExposureKeyMapper();
_keyFilter = new KeyFilter(_keyMapper, _keyValidator.Object, mapper, _logger.Object, _repository.Object);
}
public ListQueryResult(IKeyFilter kf, IKeyFilter cf, IList result) : this(kf, cf)
{
_resultKeys.AddRange(result);
}
internal static void AddKeyFilter (IKeyFilter value)
{
XplatUI.AddKeyFilter (value);
}
public HashedQueryResult(IKeyFilter keyFilter, IKeyFilter compoundFilter)
{
this.KeyFilter = KeyFilter;
this.CompoundFilter = compoundFilter;
}
public HashSetQueryResult(IKeyFilter kf, IKeyFilter cf)
{
this.KeyFilter = kf;
this.CompoundFilter = cf;
}
/// <summary>
/// 根据查询条件返回数据
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
private void WrapData(JsonResult result)
{
var baseQuery = result.Data as IQueryable <T>;
var queryManager = SiteManager.Get <AdvQueryManager>();
if (String.IsNullOrWhiteSpace(_pageModel.SortExpression))
{
_pageModel.SortField = "Id";
_pageModel.SortOrder = "desc";
}
if (!_pageModel.Key.IsEmpty())
{
IKeyFilter <T> keyController = _filterContext.Controller as IKeyFilter <T>;
Func <string, Expression <Func <T, bool> > > func = BuildDefaultKeyFilter;
if (keyController != null)
{
func = keyController.GetKeyFilter;
}
string[] keys = _pageModel.Key.Split(' ');
_keyFilter = null;
foreach (string key in keys)
{
if (!String.IsNullOrWhiteSpace(key))
{
_keyFilter = _keyFilter.And(func(key));
}
}
baseQuery = baseQuery.Where(_keyFilter);
}
else if (!_pageModel.AdvQuery.IsEmpty())
{
int queryType = CommOp.ToInt(_filterContext.HttpContext.Request["QueryType"]);
//调用服务层业务逻辑获取分页数据
baseQuery = queryManager.Query(baseQuery, _pageModel.AdvQuery, queryType);
}
if (_pageModel.PageSize == 0) //不分页的情况
{
result.Data = baseQuery;
}
else
{
Pager <T> pageData = null;
_pageModel.PageIndex++;//MiniUI的分页数字是从0开始，实际的分页是从1开始的，这里+1同步。
pageData = new Pager <T>(baseQuery.OrderBy(_pageModel.SortExpression), _pageModel.PageIndex, _pageModel.PageSize);
//让用户有机会在数据返回前作一些处理
var pagedController = _filterContext.Controller as IPagedDataController <T>;
if (pagedController != null)
{
pagedController.BeforeShowingPage(pageData);
}
//根据mini-UI的mini-grid控件的约定返回数据
result.Data = new
{
data = pageData,
total = pageData.RecordCount
};
}
queryManager.Dispose();
result.JsonRequestBehavior = JsonRequestBehavior.AllowGet;
}
internal static void AddKeyFilter (IKeyFilter value)
{
lock (key_filters) {
key_filters.Add (value);
}
}
public ListQueryResult(IKeyFilter kf, IKeyFilter cf)
{
KeyFilter = kf;
CompoundFilter = cf;
}
public virtual void ExecuteMapReduceTask(MapReduceTask task, string taskId, MROutputOption option,
short callbackId, IKeyFilter keyfilter, string query, Hashtable parameters)
{
}
internal static void AddKeyFilter(IKeyFilter value)
{
XplatUI.AddKeyFilter(value);
}
public Filter(IKeyFilter keyFilter)
{
this.keyFilter = keyFilter;
}
