Example #1
0
        /// <summary>Entfernt ein Updatepaket aus dem Projekt.</summary>
        public void removeUpdatePackage(updatePackage package)
        {
            //Updatepaket löschen
            string packagePath = Path.Combine(Path.Combine(Path.GetDirectoryName(_session.currentProjectPath), "Updates"),
                                              package.getFilename());

            if (File.Exists(packagePath))
            {
                File.Delete(packagePath);
            }

            //Changelog löschen
            string changelogPath = Path.Combine(Path.Combine(Path.GetDirectoryName(_session.currentProjectPath), "Updates"),
                                                package.getChangelogFilename());

            if (File.Exists(changelogPath))
            {
                File.Delete(changelogPath);
            }

            //Von allen Providern die Verknüpfung zu diesem Projekt entfernen
            foreach (var provider in _session.currentProject.publishProvider)
            {
                unlinkUpdate(package, provider);
            }

            //Paket aus dem Projekt werfen
            _session.currentProject.updatePackages.Remove(package);
        }
Example #2
0
        public void buildUpdatePackage(updatePackage package, string changesDe, string changesEn)
        {
            //Argumente prüfen
            if (package == null)
            {
                throw new ArgumentException("package");
            }
            if (string.IsNullOrEmpty(changesDe) && string.IsNullOrEmpty(changesEn))
            {
                throw new ArgumentException("changesDe und changesEn");
            }

            //Prüfen ob das Projekt schon gespeichert wurde (notwendig!)
            if (string.IsNullOrEmpty(_session.currentProjectPath))
            {
                throw new Exception("Das Projekt muss gespeichert werden bevor Updatepakete erstellt werden können.");
            }

            //Lokales Basisverzeichnis für die Aktualisieren bestimmen.
            string updateDirectory = Path.Combine(Path.GetDirectoryName(_session.currentProjectPath), _projectStructure[0]);

            //Updatepaket für die Dateien erstellen
            using (var fsUpdatePackage = new FileStream(Path.Combine(updateDirectory, package.getFilename()), FileMode.Create)) {
                using (var writer = new ResourceWriter(fsUpdatePackage)) {
                    //Jede Datei ins Paket schreiben und vorher komprimieren
                    foreach (var fcAction in package.fileCopyActions)
                    {
                        foreach (var fileData in fcAction.Files)
                        {
                            if (File.Exists(fileData.Fullpath))
                            {
                                writer.AddResourceData(fileData.ID, "fileCopyActionData", compressData(File.ReadAllBytes(fileData.Fullpath)));
                            }
                        }
                    }
                    writer.Generate();
                }
            }

            //Paketgröße setzen
            package.packageSize = new FileInfo(Path.Combine(updateDirectory, package.getFilename())).Length;

            string packageHash =
                Convert.ToBase64String(
                    SHA512.Create().ComputeHash(File.ReadAllBytes(Path.Combine(updateDirectory, package.getFilename()))));

            package.packageSignature = updateSystemDotNet.Core.RSA.Sign(packageHash, _session.currentProject.keyPair.privateKey);

            //Changelog erstellen und speichern
            XmlDocument xChangelog = createChangelogs(changesDe, changesEn);

            using (var xWriter = new StreamWriter(Path.Combine(updateDirectory, package.getChangelogFilename()), false, Encoding.UTF8)) {
                xChangelog.Save(xWriter);
            }
        }
Example #3
0
        public prepareEditPackageResult prepareEditUpdatePackage(updatePackage package)
        {
            var result = new prepareEditPackageResult();

            //Temporäres Verzeichnis für die Updatedaten erstellen
            string tempPackagePath = Path.Combine(Environment.GetEnvironmentVariable("tmp"), package.ID);

            result.tempPackagePath = tempPackagePath;
            result.updatePackage   = package;

            if (!Directory.Exists(tempPackagePath))
            {
                Directory.CreateDirectory(tempPackagePath);
            }

            //Pfad zum Updatepaket ermitteln
            string packagePath = Path.Combine(Path.Combine(_session.currentProjectDirectory, "Updates"), package.getFilename());

            if (!File.Exists(packagePath))
            {
                throw new FileNotFoundException("Das Updatepaket konnte nicht gefunden werden.", packagePath);
            }

            //Updatepaket öffnen
            using (var fsPackage = File.OpenRead(packagePath)) {
                using (var packageReader = new ResourceReader(fsPackage)) {
                    //Dateien entpacken und im Tempverzeichnis abspeichern
                    foreach (var copyAction in package.fileCopyActions)
                    {
                        foreach (var file in copyAction.Files)
                        {
                            string newFilename = string.Format("{0}.{1}", file.ID, file.Filename);
                            using (var fsFileOut = new FileStream(Path.Combine(tempPackagePath, newFilename), FileMode.Create)) {
                                byte[] resourceData;
                                string tempType;                                 //ungenutzt aber trotzdem notwendig
                                packageReader.GetResourceData(file.ID, out tempType, out resourceData);
                                byte[] decompressedData = decompressData(resourceData);
                                fsFileOut.Write(decompressedData, 0, decompressedData.Length);
                            }

                            //Neuen Dateinamen in Updatepaket übernehmen
                            file.Fullpath = Path.Combine(tempPackagePath, newFilename);
                        }
                    }
                }
            }

            //Changelog lesen
            string changelogPath = Path.Combine(Path.Combine(_session.currentProjectDirectory, "Updates"),
                                                package.getChangelogFilename());

            if (!File.Exists(changelogPath))
            {
                throw new FileNotFoundException("Der Changelog konnte nicht gefunden werden", changelogPath);
            }

            using (var fsChangelog = new StreamReader(changelogPath, Encoding.UTF8)) {
                var xmlChangelog = new XmlDocument();
                xmlChangelog.Load(fsChangelog);

                XmlNodeList changelogItems = xmlChangelog.SelectNodes("updateSystemDotNet.Changelog/Items/Item");
                if (changelogItems == null)
                {
                    throw new InvalidOperationException("Es konnte im Changelog keine Änderungseinträge gefunden werden.");
                }

                if (changelogItems.Count >= 1 && changelogItems[0].SelectSingleNode("Change") != null)
                {
                    result.changelogGerman = changelogItems[0].SelectSingleNode("Change").InnerText;
                }
                if (changelogItems.Count >= 2 && changelogItems[1].SelectSingleNode("Change") != null)
                {
                    result.changelogEnglish = changelogItems[1].SelectSingleNode("Change").InnerText;
                }
            }

            return(result);
        }