private void init()
        {
            _activationCodes.Clear();

            if (_settings.ActivationCode.HasValue)
            {
                Log(2, this, "from user settings");
                _activationCodes.Add(_settings.ActivationCode.Value.ToHexString());
            }

            if (!HasActivationCode)
            {
                ActivationCodeRegistry registryCodes = new ActivationCodeRegistry();
                if (registryCodes.HasActivationCode)
                {
                    Log(2, this, "from registry");
                    _activationCodes = _activationCodes.Union(registryCodes.ActivationCodes).ToList();
                }
            }

            if (!HasActivationCode)
            {
                ActivationCodeApp appCodes = new ActivationCodeApp();
                if (appCodes.HasActivationCode)
                {
                    Log(2, this, "from app");
                    _activationCodes = _activationCodes.Union(appCodes.ActivationCodes).ToList();
                }
            }
        }
Example #2
0
        public ActivationCode(IActivationSettings settings)
        {
            if (settings.ActivationCode.HasValue)
            {
                _activationCodes.Add(settings.ActivationCode.Value.ToHexString());
            }

            if (!HasActivationCode)
            {
                ActivationCodeRegistry registryCodes = new ActivationCodeRegistry();
                if (registryCodes.HasActivationCode)
                {
                    _activationCodes = _activationCodes.Union(registryCodes.ActivationCodes).ToList();
                }
            }

            if (!HasActivationCode)
            {
                ActivationCodeApp appCodes = new ActivationCodeApp();
                if (appCodes.HasActivationCode)
                {
                    _activationCodes = _activationCodes.Union(appCodes.ActivationCodes).ToList();
                }
            }
        }
        private void init()
        {
            _activationCodes.Clear();

            if (_settings.ActivationCode.HasValue)
            {
                Log(2, this, "add from user settings");
                _activationCodes.Add(_settings.ActivationCode.Value.ToHexString());
            }

            {
                ActivationCodeRegistry registryCodes = new ActivationCodeRegistry();
                if (registryCodes.HasActivationCode)
                {
                    Log(2, this, $"add from registry (#={registryCodes.ActivationCodes.Count()})");
                    _activationCodes = _activationCodes.Union(registryCodes.ActivationCodes).ToList();
                }
            }

            {
                ActivationCodeApp appCodes = new ActivationCodeApp();
                if (appCodes.HasActivationCode)
                {
                    Log(2, this, $"add from app (#={appCodes.ActivationCodes.Count()})");
                    _activationCodes = _activationCodes.Union(appCodes.ActivationCodes).ToList();
                }
            }

            Log(2, this, $"#unique={_activationCodes.Count}");
        }
Example #4
0
            public static IEnumerable <string> GetAbsolutePaths(string subDir)
            {
                var absDirs = ActivationCodeApp.GetPackageDirectories();

                if (absDirs is null)
                {
                    return(null);
                }
                var subDirPaths = absDirs.Select(d => Path.Combine(d, subDir));

                return(subDirPaths);
            }
        private string findContentMetadataFile(string fileName)
        {
            // try to find content metadata files, either relative or absolute
            Log(3, this, () => $"\"{fileName.SubstitUser ()}\"");

            // relative
            string cntDir        = Path.GetDirectoryName(fileName);
            var    diLocalState  = Directory.GetParent(cntDir);
            string localStateDir = diLocalState.FullName;
            string cacheDir      = Path.Combine(localStateDir, FILESCACHE);
            var    dirs          = new List <string> ();

            if (Directory.Exists(cacheDir))
            {
                dirs.Add(cacheDir);
            }
            else
            {
                // absolute
                var absDirs = ActivationCodeApp.GetPackageDirectories();
                if (absDirs is null)
                {
                    return(null);
                }
                foreach (var absDir in absDirs)
                {
                    cacheDir = Path.Combine(absDir, FILESCACHE);
                    if (Directory.Exists(cacheDir))
                    {
                        dirs.Add(cacheDir);
                    }
                }
            }

            if (dirs.Count == 0)
            {
                return(null);
            }

            // get all content metadata filenames
            var files = dirs.SelectMany(d => Directory.GetFiles(d, $"{CONTENT_METADATA}*{JSON}")).Distinct();

            // isolate asin
            var asinFiles = new List <ContentMetadataFile> ();

            foreach (string file in files)
            {
                var fn    = Path.GetFileNameWithoutExtension(file);
                var match = __regexAsin.Match(fn);
                if (!match.Success)
                {
                    continue;
                }
                string asin = match.Groups[1].Value;
                asinFiles.Add(new ContentMetadataFile(file, asin));
            }

            // find matching asin in our filename
            var    filnam          = Path.GetFileNameWithoutExtension(fileName);
            string contentMetafile = asinFiles.Where(k => filnam.Contains(k.ASIN)).Select(k => k.Filename).FirstOrDefault();

            Log(3, this, () => $"\"{contentMetafile.SubstitUser ()}\"");

            return(contentMetafile);
        }
Example #6
0
        private ContentMetadataFile findContentMetadataFile(string fileName)
        {
            // try to find content metadata file, either locally, relative or absolute

            // find and isolate asin
            string fn    = Path.GetFileNameWithoutExtension(fileName);
            var    match = __regexAsinAax.Match(fn);

            if (!match.Success)
            {
                Log(3, this, () => $"ASIN not found.");
                return(null);
            }
            string asin = match.Groups[1].Value;

            Log(3, this, () => $"ASIN={asin}");

            string contentDir      = Path.GetDirectoryName(fileName).StripUnc();
            string contentmetafile = CONTENT_METADATA + asin + JSON;

            {
                // local
                string localPath = Path.Combine(contentDir, contentmetafile).AsUncIfLong();
                if (File.Exists(localPath))
                {
                    return(new ContentMetadataFile(localPath, asin));
                }
            }
            {
                // relative
                var diLocalState = Directory.GetParent(contentDir);
                if (!(diLocalState is null))
                {
                    string localStateDir = diLocalState.FullName;
                    string cacheDir      = Path.Combine(localStateDir, FILESCACHE);

                    string relativePath = Path.Combine(cacheDir, contentmetafile).AsUncIfLong();
                    if (File.Exists(relativePath))
                    {
                        return(new ContentMetadataFile(relativePath, asin));
                    }
                }
            }
            {
                // absolute
                var absDirs = ActivationCodeApp.GetPackageDirectories();
                if (absDirs is null)
                {
                    return(null);
                }
                var cacheDirs = absDirs.Select(d => Path.Combine(d, FILESCACHE));
                foreach (var cacheDir in cacheDirs)
                {
                    string absolutePath = Path.Combine(cacheDir, contentmetafile).AsUncIfLong();
                    if (File.Exists(absolutePath))
                    {
                        return(new ContentMetadataFile(absolutePath, asin));
                    }
                }
            }

            Log(3, this, () => $"{contentmetafile} not found.");
            return(null);
        }