Example #1
0
        protected virtual void CreateNewSolutionPackage(MetaPackServiceContext service,
                                                        RegressinModelLevel modelLevel)
        {
            var solutionPackage = CreateNewSolutionPackage(service.PackagingService, null, modelLevel);

            UpdatePackageVersion(solutionPackage);
            PushPackageToCIRepository(solutionPackage, null, service.PackagingService);
        }
Example #2
0
        protected virtual SolutionPackageBase CreateNewSolutionPackage(
            NuGetSolutionPackageService service,
            Action <SolutionPackageBase> action,
            RegressinModelLevel modelLevel)
        {
            var knownPackageType = false;

            SolutionPackageBase solutionPackage = null;

            if (service is SPMeta2SolutionPackageService)
            {
                var m2package = new SolutionPackageBase();

                m2package.Name  = "SPMeta2 CI Package Name";
                m2package.Title = "SPMeta2 CI Package Title";

                m2package.Description = "SPMeta2 CI Package description";
                m2package.Id          = "MetaPack.SPMeta2.CI";
                m2package.Authors     = "SubPoint Solutions Authors";
                m2package.Company     = "SubPoint Solutions Company";
                m2package.Version     = "1.0.0.0";
                m2package.Owners      = "SubPoint Solutions Owners";

                m2package.ReleaseNotes = "ReleaseNotes";
                m2package.Summary      = "Summary";
                m2package.ProjectUrl   = "https://github.com/SubPointSolutions/metapack";
                m2package.IconUrl      = "https://github.com/SubPointSolutions/metapack/metapack.png";
                m2package.LicenseUrl   = "https://opensource.org/licenses/MIT";

                m2package.Copyright = "Some copyright here";
                m2package.Tags      = "CI SPMeta2 MetaPack Tags";

                var models = new List <ModelNode>();

                switch (modelLevel)
                {
                case RegressinModelLevel.Farm:
                    models.Add(SPMeta2Model.NewFarmModel(farm => { }));
                    break;

                case RegressinModelLevel.WebApplication:
                    models.Add(SPMeta2Model.NewWebApplicationModel(webApp => { }));
                    break;

                case RegressinModelLevel.Site:
                    models.Add(SPMeta2Model.NewSiteModel(site => { }));
                    models.Add(SPMeta2Model.NewWebModel(web => { }));
                    break;

                case RegressinModelLevel.Web:
                    models.Add(SPMeta2Model.NewWebModel(web => { }));
                    break;

                case RegressinModelLevel.Subweb:
                    models.Add(SPMeta2Model.NewWebModel(web => { }));
                    break;

                default:
                    throw new NotImplementedException(string.Format(
                                                          "Unsupported model level:[{0}] for model genaration",
                                                          modelLevel));
                }

                var index = 0;

                foreach (var model in models)
                {
                    index++;

                    var xmlContext = SPMeta2Model.ToXML(model);

                    var modelContainer = new ModelContainerBase
                    {
                        Model = Encoding.UTF8.GetBytes(xmlContext),
                    };

                    modelContainer.AdditionalOptions.Add(new OptionValue
                    {
                        Name  = DefaultOptions.Model.Order.Id,
                        Value = index.ToString()
                    });

                    m2package.AddModel(modelContainer);
                }

                m2package.AdditionalOptions.Add(new OptionValue
                {
                    Name  = DefaultOptions.SolutionToolPackage.PackageId.Id,
                    Value = "MetaPack.SPMeta2"
                });

                solutionPackage = m2package;
            }

            if (service is SharePointPnPSolutionPackageService)
            {
                var pnpPackage = new SolutionPackageBase();

                pnpPackage.Name  = "SharePointPnP CI Package Name";
                pnpPackage.Title = "SharePointPnP Package Title";

                pnpPackage.Description = "SPMeta2 CI Package description";
                pnpPackage.Id          = "MetaPack.SharePointPnP.CI";
                pnpPackage.Authors     = "SubPoint Solutions Authors";
                pnpPackage.Company     = "SubPoint Solutions Company";
                pnpPackage.Version     = "1.0.0.0";
                pnpPackage.Owners      = "SubPoint Solutions Owners";

                pnpPackage.ReleaseNotes = "ReleaseNotes";
                pnpPackage.Summary      = "Summary";
                pnpPackage.ProjectUrl   = "https://github.com/SubPointSolutions/metapack";
                pnpPackage.IconUrl      = "https://github.com/SubPointSolutions/metapack/metapack.png";
                pnpPackage.LicenseUrl   = "https://opensource.org/licenses/MIT";

                pnpPackage.Copyright = "Some copyright here";
                pnpPackage.Tags      = "CI SPMeta2 MetaPack Tags";


                // TODO
                // Zip up and set the model type
                var asmFolder = Path.GetDirectoryName(GetType().Assembly.Location);

                var foldersPath       = Path.Combine(asmFolder, @"Data/PnPTemplates/Folders");
                var openXmlFolderPath = Path.Combine(asmFolder, @"Data/PnPTemplates/OpenXML");

                foreach (var templateFolder in Directory.GetDirectories(foldersPath))
                {
                    // package up into zip
                    var templateFolderZipFile = GetTempZipFilePath();
                    ZipFile.CreateFromDirectory(templateFolder, templateFolderZipFile);

                    var modelContainer = new ModelContainerBase
                    {
                        Model = System.IO.File.ReadAllBytes(templateFolderZipFile),
                    };

                    modelContainer.AdditionalOptions.Add(new OptionValue
                    {
                        Name  = DefaultOptions.Model.Type.Id,
                        Value = "SharePointPnP.FolderZip"
                    });

                    pnpPackage.AddModel(modelContainer);
                }



                var openXmlPackages = Directory.GetFiles(openXmlFolderPath, "*.pnp");

                foreach (var file in openXmlPackages)
                {
                    var modelContainer = new ModelContainerBase
                    {
                        Model = System.IO.File.ReadAllBytes(file),
                    };

                    modelContainer.AdditionalOptions.Add(new OptionValue
                    {
                        Name  = DefaultOptions.Model.Type.Id,
                        Value = "SharePointPnP.OpenXml"
                    });

                    pnpPackage.AddModel(modelContainer);
                }

                pnpPackage.AdditionalOptions.Add(new OptionValue
                {
                    Name  = DefaultOptions.SolutionToolPackage.PackageId.Id,
                    Value = "MetaPack.SharePointPnP"
                });

                solutionPackage = pnpPackage;
            }

            if (solutionPackage == null)
            {
                throw new NotImplementedException(string.Format(
                                                      "Unknown service type:[{0}]", service.GetType()));
            }

            if (action != null)
            {
                action(solutionPackage);
            }

            return(solutionPackage);
        }
Example #3
0
 protected virtual SolutionPackageBase CreateNewSolutionPackage(NuGetSolutionPackageService service,
                                                                RegressinModelLevel modelLevel)
 {
     return(CreateNewSolutionPackage(service, null, modelLevel));
 }