public static async Task <MBRegistrationRecord> GetRegistrationStatus(IHttpClient httpClient, IJsonSerializer jsonSerializer, string feature, string mb2Equivalent = null, string version = null)
        {
            //check the reg file first to alleviate strain on the MB admin server - must actually check in every 30 days tho
            var reg = new RegRecord {
                registered = LicenseFile.LastChecked(feature) > DateTime.UtcNow.AddDays(-30)
            };
            var success = reg.registered;

            if (!reg.registered)
            {
                var mac  = _networkManager.GetMacAddress();
                var data = new Dictionary <string, string>
                {
                    { "feature", feature },
                    { "key", SupporterKey },
                    { "mac", mac },
                    { "mb2equiv", mb2Equivalent },
                    { "legacykey", LegacyKey },
                    { "ver", version },
                    { "platform", Environment.OSVersion.VersionString },
                    { "isservice", _applicationHost.IsRunningAsService.ToString().ToLower() }
                };

                try
                {
                    using (var json = await httpClient.Post(MBValidateUrl, data, CancellationToken.None).ConfigureAwait(false))
                    {
                        reg     = jsonSerializer.DeserializeFromStream <RegRecord>(json);
                        success = true;
                    }

                    if (reg.registered)
                    {
                        LicenseFile.AddRegCheck(feature);
                    }
                    else
                    {
                        LicenseFile.RemoveRegCheck(feature);
                    }
                }
                catch (Exception e)
                {
                    _logger.ErrorException("Error checking registration status of {0}", e, feature);
                }
            }

            return(new MBRegistrationRecord {
                IsRegistered = reg.registered, ExpirationDate = reg.expDate, RegChecked = true, RegError = !success
            });
        }
Example #2
0
        private async Task <MBRegistrationRecord> GetRegistrationStatusInternal(string feature,
                                                                                string mb2Equivalent = null,
                                                                                string version       = null)
        {
            var lastChecked = LicenseFile.LastChecked(feature);

            //check the reg file first to alleviate strain on the MB admin server - must actually check in every 30 days tho
            var reg = new RegRecord
            {
                // Cache the result for up to a week
                registered = lastChecked > DateTime.UtcNow.AddDays(-7)
            };

            var success = reg.registered;

            if (!(lastChecked > DateTime.UtcNow.AddDays(-1)))
            {
                var data = new Dictionary <string, string>
                {
                    { "feature", feature },
                    { "key", SupporterKey },
                    { "mac", _appHost.SystemId },
                    { "systemid", _appHost.SystemId },
                    { "mb2equiv", mb2Equivalent },
                    { "ver", version },
                    { "platform", _appHost.OperatingSystemDisplayName },
                    { "isservice", _appHost.IsRunningAsService.ToString().ToLower() }
                };

                try
                {
                    var options = new HttpRequestOptions
                    {
                        Url = MBValidateUrl,

                        // Seeing block length errors
                        EnableHttpCompression = false
                    };

                    options.SetPostData(data);

                    using (var json = (await _httpClient.Post(options).ConfigureAwait(false)).Content)
                    {
                        reg     = _jsonSerializer.DeserializeFromStream <RegRecord>(json);
                        success = true;
                    }

                    if (reg.registered)
                    {
                        LicenseFile.AddRegCheck(feature);
                    }
                    else
                    {
                        LicenseFile.RemoveRegCheck(feature);
                    }
                }
                catch (Exception e)
                {
                    _logger.ErrorException("Error checking registration status of {0}", e, feature);
                }
            }

            var record = new MBRegistrationRecord
            {
                IsRegistered   = reg.registered,
                ExpirationDate = reg.expDate,
                RegChecked     = true,
                RegError       = !success
            };

            record.TrialVersion = IsInTrial(reg.expDate, record.RegChecked, record.IsRegistered);
            record.IsValid      = !record.RegChecked || record.IsRegistered || record.TrialVersion;

            return(record);
        }
Example #3
0
        private async Task <MBRegistrationRecord> GetRegistrationStatusInternal(string feature,
                                                                                string version = null)
        {
            var regInfo     = LicenseFile.GetRegInfo(feature);
            var lastChecked = regInfo == null ? DateTime.MinValue : regInfo.LastChecked;
            var expDate     = regInfo == null ? DateTime.MinValue : regInfo.ExpirationDate;

            var maxCacheDays = 14;
            var nextCheckDate = new [] { expDate, lastChecked.AddDays(maxCacheDays) }.Min();

            if (nextCheckDate > DateTime.UtcNow.AddDays(maxCacheDays))
            {
                nextCheckDate = DateTime.MinValue;
            }

            //check the reg file first to alleviate strain on the MB admin server - must actually check in every 30 days tho
            var reg = new RegRecord
            {
                // Cache the result for up to a week
                registered = regInfo != null && nextCheckDate >= DateTime.UtcNow && expDate >= DateTime.UtcNow,
                expDate    = expDate
            };

            var key = SupporterKey;

            var success = reg.registered;

            if (!(lastChecked > DateTime.UtcNow.AddDays(-1)) || (!reg.registered))
            {
                var data = new Dictionary <string, string>
                {
                    { "feature", feature },
                    { "key", key },
                    { "mac", _appHost.SystemId },
                    { "systemid", _appHost.SystemId },
                    { "ver", version },
                    { "platform", _appHost.OperatingSystemDisplayName }
                };

                try
                {
                    var options = new HttpRequestOptions
                    {
                        Url = MBValidateUrl,

                        // Seeing block length errors
                        EnableHttpCompression = false,
                        BufferContent         = false
                    };

                    options.SetPostData(data);

                    using (var response = (await _httpClient.Post(options).ConfigureAwait(false)))
                    {
                        using (var json = response.Content)
                        {
                            reg     = _jsonSerializer.DeserializeFromStream <RegRecord>(json);
                            success = true;
                        }
                    }

                    if (reg.registered)
                    {
                        _logger.Info("Registered for feature {0}", feature);
                        LicenseFile.AddRegCheck(feature, reg.expDate);
                    }
                    else
                    {
                        _logger.Info("Not registered for feature {0}", feature);
                        LicenseFile.RemoveRegCheck(feature);
                    }
                }
                catch (Exception e)
                {
                    _logger.ErrorException("Error checking registration status of {0}", e, feature);
                }
            }

            var record = new MBRegistrationRecord
            {
                IsRegistered = true,
                RegChecked   = true,
                TrialVersion = false,
                IsValid      = true,
                RegError     = false
            };

            record.TrialVersion = IsInTrial(reg.expDate, record.RegChecked, record.IsRegistered);
            record.IsValid      = !record.RegChecked || record.IsRegistered || record.TrialVersion;

            return(record);
        }