public virtual async Task DeleteAsync(string name, string providerName, string providerKey)
        {
            var featureValue = await FeatureValueRepository.FindAsync(name, providerName, providerKey);

            if (featureValue != null)
            {
                await FeatureValueRepository.DeleteAsync(featureValue);
            }
        }
Esempio n. 2
0
        public async Task DeleteAsync(string name, string providerName, string providerKey)
        {
            var featureValue = await FeatureValueRepository.FindAsync(name, providerName, providerKey).ConfigureAwait(false);

            if (featureValue != null)
            {
                await FeatureValueRepository.DeleteAsync(featureValue).ConfigureAwait(false);
            }
        }
        public virtual async Task SetAsync(string name, string value, string providerName, string providerKey)
        {
            var featureValue = await FeatureValueRepository.FindAsync(name, providerName, providerKey);

            if (featureValue == null)
            {
                featureValue = new FeatureValue(GuidGenerator.Create(), name, value, providerName, providerKey);
                await FeatureValueRepository.InsertAsync(featureValue);
            }
            else
            {
                featureValue.Value = value;
                await FeatureValueRepository.UpdateAsync(featureValue);
            }
        }
Esempio n. 4
0
    public virtual async Task SetAsync(string name, string value, string providerName, string providerKey)
    {
        var featureValue = await FeatureValueRepository.FindAsync(name, providerName, providerKey);

        if (featureValue == null)
        {
            featureValue = new FeatureValue(GuidGenerator.Create(), name, value, providerName, providerKey);
            await FeatureValueRepository.InsertAsync(featureValue);
        }
        else
        {
            featureValue.Value = value;
            await FeatureValueRepository.UpdateAsync(featureValue);
        }

        await Cache.SetAsync(CalculateCacheKey(name, providerName, providerKey), new FeatureValueCacheItem(featureValue?.Value), considerUow : true);
    }
    public async Task SetAsync()
    {
        // Arrange
        (await FeatureValueRepository.FindAsync(TestFeatureDefinitionProvider.SocialLogins,
                                                EditionFeatureValueProvider.ProviderName,
                                                TestEditionIds.Regular.ToString())).Value.ShouldBe(true.ToString().ToLowerInvariant());

        // Act
        await FeatureManagementStore.SetAsync(TestFeatureDefinitionProvider.SocialLogins,
                                              false.ToString().ToUpperInvariant(),
                                              EditionFeatureValueProvider.ProviderName,
                                              TestEditionIds.Regular.ToString());

        // Assert
        (await FeatureValueRepository.FindAsync(TestFeatureDefinitionProvider.SocialLogins,
                                                EditionFeatureValueProvider.ProviderName,
                                                TestEditionIds.Regular.ToString())).Value.ShouldBe(false.ToString().ToUpperInvariant());
    }
    public async Task DeleteAsync()
    {
        // Arrange
        (await FeatureValueRepository.FindAsync(TestFeatureDefinitionProvider.SocialLogins,
                                                EditionFeatureValueProvider.ProviderName,
                                                TestEditionIds.Regular.ToString())).ShouldNotBeNull();

        // Act
        await FeatureManagementStore.DeleteAsync(TestFeatureDefinitionProvider.SocialLogins,
                                                 EditionFeatureValueProvider.ProviderName,
                                                 TestEditionIds.Regular.ToString());


        // Assert
        (await FeatureValueRepository.FindAsync(TestFeatureDefinitionProvider.SocialLogins,
                                                EditionFeatureValueProvider.ProviderName,
                                                TestEditionIds.Regular.ToString())).ShouldBeNull();
    }
        protected virtual async Task <FeatureValueCacheItem> GetCacheItemAsync(string name, string providerName, string providerKey)
        {
            var cacheKey  = CalculateCacheKey(name, providerName, providerKey);
            var cacheItem = await Cache.GetAsync(cacheKey);

            if (cacheItem != null)
            {
                return(cacheItem);
            }

            var featureValue = await FeatureValueRepository.FindAsync(name, providerName, providerKey);

            cacheItem = new FeatureValueCacheItem(featureValue?.Value);

            await Cache.SetAsync(
                cacheKey,
                cacheItem
                );

            return(cacheItem);
        }