Esempio n. 1
0
        public async Task Migrate(TermsType termsType, bool isAgree)
        {
            loggerService.StartMethod();

            var applicationPropertyKey = termsType == TermsType.TermsOfService ? TermsOfServiceLastUpdateDateKey : PrivacyPolicyLastUpdateDateKey;
            var preferenceKey          = termsType == TermsType.TermsOfService ? PreferenceKey.TermsOfServiceLastUpdateDateTime : PreferenceKey.PrivacyPolicyLastUpdateDateTime;

            if (preferencesService.ContainsKey(applicationPropertyKey))
            {
                return;
            }

            if (isAgree)
            {
                if (applicationPropertyService.ContainsKey(applicationPropertyKey))
                {
                    var lastUpdateDate = (DateTime)applicationPropertyService.GetProperties(applicationPropertyKey);
                    preferencesService.SetValue(preferenceKey, lastUpdateDate);
                }
                else
                {
                    preferencesService.SetValue(preferenceKey, new DateTime());
                }
            }

            await applicationPropertyService.Remove(applicationPropertyKey);

            loggerService.EndMethod();
        }
Esempio n. 2
0
        public async Task Migrate()
        {
            await _semaphoreForMigrage.WaitAsync();

            loggerService.StartMethod();
            try
            {
                var userData = GetFromApplicationProperties();
                if (userData == null)
                {
                    return;
                }

                if (userData.StartDateTime != null && !userData.StartDateTime.Equals(new DateTime()))
                {
                    preferencesService.SetValue(PreferenceKey.StartDateTime, userData.StartDateTime);
                    userData.StartDateTime = new DateTime();
                    loggerService.Info("Migrated StartDateTime");
                }

                if (userData.IsOptined)
                {
                    await termsUpdateService.Migrate(TermsType.TermsOfService, userData.IsOptined);

                    userData.IsOptined = false;
                }
                if (userData.IsPolicyAccepted)
                {
                    await termsUpdateService.Migrate(TermsType.PrivacyPolicy, userData.IsPolicyAccepted);

                    userData.IsPolicyAccepted = false;
                }

                await exposureNotificationService.MigrateFromUserData(userData);

                await applicationPropertyService.Remove("UserData");
            }
            catch (Exception ex)
            {
                loggerService.Exception("Failed migrate", ex);
            }
            finally
            {
                _semaphoreForMigrage.Release();
                loggerService.EndMethod();
            }
        }
Esempio n. 3
0
        public async Task MigrateFromUserData(UserDataModel userData)
        {
            loggerService.StartMethod();

            const string ConfigurationPropertyKey = "ExposureNotificationConfigration";

            if (userData.LastProcessTekTimestamp != null && userData.LastProcessTekTimestamp.Count > 0)
            {
                var stringValue = Utils.SerializeToJson(userData.LastProcessTekTimestamp);
                preferencesService.SetValue(PreferenceKey.LastProcessTekTimestamp, stringValue);
                userData.LastProcessTekTimestamp.Clear();
                loggerService.Info("Migrated LastProcessTekTimestamp");
            }

            if (applicationPropertyService.ContainsKey(ConfigurationPropertyKey))
            {
                var configuration = applicationPropertyService.GetProperties(ConfigurationPropertyKey) as string;
                if (!string.IsNullOrEmpty(configuration))
                {
                    preferencesService.SetValue(PreferenceKey.ExposureNotificationConfiguration, configuration);
                }
                await applicationPropertyService.Remove(ConfigurationPropertyKey);

                loggerService.Info("Migrated ExposureNotificationConfiguration");
            }

            if (userData.ExposureInformation != null)
            {
                secureStorageService.SetValue(PreferenceKey.ExposureInformation, JsonConvert.SerializeObject(userData.ExposureInformation));
                userData.ExposureInformation = null;
                loggerService.Info("Migrated ExposureInformation");
            }

            if (userData.ExposureSummary != null)
            {
                secureStorageService.SetValue(PreferenceKey.ExposureSummary, JsonConvert.SerializeObject(userData.ExposureSummary));
                userData.ExposureSummary = null;
                loggerService.Info("Migrated ExposureSummary");
            }

            loggerService.EndMethod();
        }