Esempio n. 1
0
        static int Main(string[] args)
        {
            ManifestConfiguration config = ParseArguments(args);

            if (!ValidateConfiguration(config))
            {
                PrintConsoleHelp();
                return -1;
            }

            string rootDirPath = Path.GetFullPath(config.RootDirectory);
            string manifestFilePath = Path.GetFullPath(config.ManifestFilePath);

            if (!Directory.Exists(rootDirPath))
            {
                Console.WriteLine("\nThe directory specified does not exist.");
                return -1;
            }

            if (config.CheckManifest && !File.Exists(manifestFilePath))
            {
                Console.WriteLine("\nThe manifest file does not exist.");
                return -1;
            }

            if (config.BuildManifest)
            {
                FileManifest manifest = FileManifestFactory.Create(rootDirPath);

                FileWriter.WriteManifest(manifest, manifestFilePath);
            }

            if (config.CheckManifest)
            {
                string reportFilePath = Path.GetFullPath(config.ReportFilePath);

                FileManifest baselineManifest = ManifestReader.ReadManifest(manifestFilePath);
                FileManifest currentManifest = FileManifestFactory.Create(rootDirPath);

                List<FileManifestItem> missingItems = new List<FileManifestItem>();
                foreach (FileManifestItem item in baselineManifest.Items)
                {
                    if (!currentManifest.Items.Any(i => i.File == item.File))
                    {
                        missingItems.Add(item);
                    }
                }

                List<FileManifestItem> newItems = new List<FileManifestItem>();
                foreach (FileManifestItem item in currentManifest.Items)
                {
                    if (!baselineManifest.Items.Any(i => i.File == item.File))
                    {
                        newItems.Add(item);
                    }
                }

                // Diff the manifest
                Dictionary<string, int> diff = ManifestComparer.Compare(baselineManifest, currentManifest);

                List<string> equalFiles = diff.Where(d => d.Value == 0).Select(d => d.Key).ToList();
                List<string> differingFiles = diff.Where(d => d.Value != 0).Select(d => d.Key).ToList();

                List<FileManifestItem> equalItems = baselineManifest.Items.Where(i => equalFiles.Any(f => i.File == f)).ToList();
                List<FileManifestItem> differingItems = baselineManifest.Items.Where(i => differingFiles.Any(f => i.File == f)).ToList();

                List<Tuple<FileManifestItem, FileManifestItem>> diffTuples = new List<Tuple<FileManifestItem, FileManifestItem>>();
                foreach (string differingFile in differingFiles)
                {
                    FileManifestItem baselineItem = baselineManifest.Items.First(i => i.File == differingFile);
                    FileManifestItem currentItem = currentManifest.Items.First(i => i.File == differingFile);
                    diffTuples.Add(new Tuple<FileManifestItem, FileManifestItem>(baselineItem, currentItem));
                }

                DiffReport report = new DiffReport()
                {
                    EquivalentItems = equalItems,
                    DifferingItems = diffTuples,
                    MissingItems = missingItems,
                    NewItems = newItems
                };

                // TODO: This needs to be an argument.
                FileWriter.WriteReport(report, reportFilePath);
            }

            return 0;
        }
        internal static void WriteReport(DiffReport report, string filePath)
        {
            string json = JsonConvert.SerializeObject(report, Formatting.Indented);

            File.WriteAllText(filePath, json);
        }