public override SolutionPackageBase Unpack(Stream package, SolutionPackageOptions options)
        {
            package.Position = 0;

            var zipPackage          = new ZipPackage(package);
            var solutionPackageFile = FindSolutionPackageFile(zipPackage);

            SerializationService.RegisterKnownType(typeof(SolutionPackageBase));
            //SerializationService.RegisterKnownType(typeof(SPMeta2SolutionPackage));

            using (var streamReader = new StreamReader(solutionPackageFile.GetStream()))
            {
                var solutionFileContent = streamReader.ReadToEnd();

                var solutionPackage     = SerializationService.Deserialize(typeof(SolutionPackageBase), solutionFileContent) as SolutionPackageBase;
                var modelContainerFiles = zipPackage.GetFiles(MetaPackConsts.ModelsContainerFolder);

                foreach (var modelContainerFile in modelContainerFiles)
                {
                    using (var modelContainerStream = modelContainerFile.GetStream())
                    {
                        var modelContainerBinary = modelContainerStream.ReadToEnd();

                        var modelContainer = SerializationService.Deserialize(typeof(ModelContainerBase), modelContainerBinary) as ModelContainerBase;
                        solutionPackage.AddModel(modelContainer);
                    }
                }

                return(solutionPackage);
            }
        }
        public override Stream Pack(SolutionPackageBase package, SolutionPackageOptions options)
        {
            var typedPackage = package;

            MetaPackTrace.Verbose("Packing solution package...");

            // create result stream and NuGet package
            var resultStream = new MemoryStream();
            var metadata     = GetManifestMetadata(package);

            var nugetPackageBuilder = new PackageBuilder();

            var solutionPackageManifestFile = new ManifestFile();
            var solutionFilePath            = SaveMetaPackSolutionFile <SolutionPackageBase>(solutionPackageManifestFile, typedPackage);

            nugetPackageBuilder.PopulateFiles("", new[] { solutionPackageManifestFile });
            nugetPackageBuilder.Populate(metadata);

            // TODO
            // implement container persistance

            var models = package.GetModels();

            foreach (var model in models)
            {
                var modelManifestFile = GetModelManifestFile(model);
                nugetPackageBuilder.PopulateFiles("", new[] { modelManifestFile });
            }

            // save nuget package into the final stream
            nugetPackageBuilder.Save(resultStream);

            resultStream.Position = 0;

            MetaPackTrace.Verbose("Packing solution package completed...");

            return(resultStream);
        }
 public abstract SolutionPackageBase Unpack(Stream package, SolutionPackageOptions options);
Esempio n. 4
0
 public override SolutionPackageBase Unpack(Stream package, SolutionPackageOptions options)
 {
     throw new NotImplementedException();
 }
 public abstract Stream Pack(SolutionPackageBase package, SolutionPackageOptions options);