BranchesTags

Repository files navigation

MetaPack

The package manager for SPMeta2 based SharePoint customizations.

Deploying, updating and managing SharePoint customizations takes effort. Not only deployment but also versioning, modularization and dependency management require too much effort slowing down development, expanding cost and the delivery dates. Time spent on writing plumbing code, scripts or other means to handle all these areas should be spend on really important things.

MetaPack introduces a complete solution for packaging, versioning, deploying and updating SPMeta2 based customizations. It is built on top of NuGet platform and offers a smooth API for developers, a CLI for better CI/CD scenarios and a handy GUI app for IT-pros.

Here is how we see it working - develop model in Visual Studio, package and push to NuGet, consume via API later on MetaPack Vision

Link to the full image

Build status

Build status

MetaPack in details

Introduces solution packaging

Packaging SharePoint customization is never an easy task. Should it be console app? Should it be provider hosted app? A PowerShell script?

Don't worry. MetaPack packages your solution as a self-contained NuGet package. As simple as that.

Handles solution versioning

Version history is another pain point while delivering SharePoint customizations. It is not easy to keep track of all customizations deployed not to talk about versioning them.

MetaPack uses NuGet Gallery infrastructure to provide solution version tracking. Semantic versioning naturally comes along.

Makes dependency management possible

Did you ever want to reuse and modularize your customizations so that you can compose bigger building blocks? We know it's hard to implement.

MetaPack brings the best of NuGet platform: package dependency management, versioning and easy modularization.

Simplifies deployment and updates

Solution life-cycle does not end with the first deployment. New features are built, new versions are released so that a smooth update process is a must.

MetaPack offers the best experience ever to deploy and update your models. It handles all the details and even shows if updates are available.

Offers API, a CLI and user friendly GUI

Modern software development blurs the boundaries between developers, IT-pros and business. Team needs to work closely having a solid, smooth delivery workflow.

MetaPack offers ultimate experience for all team: developers leverage API, IT-pros have a CLI and business have a friendly GUI based application.

Improves CI/CD story

Ultimately, MetaPack not only helps to ship SharePoint customizations to the client but also helps to improve continues integration and deployment story.

Create SPMeta2 models in Visual Studios, use API to create NuGet packages, ship them the way you like: API, CLI or GUI - it's all yours.

As for the API, that's how you can push your SPMeta2 models into NuGet Gallery:

WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);});

Next, you can get package from the NuGet Gallery and unpack it:

WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// unpacking the solutionusing(varstreamReader=nuGetPackage.GetStream()){// here is your solution with all the modelsvarunpackedSolutionPackage=packagingService.Unpack(streamReader)asSPMeta2SolutionPackage;// do something with the solutionforeach(varmodelinunpackedSolutionPackage.Models){// do some stuff with models// deploy the way you like? }}});

But why not to deploy your solution straight to SharePoint? Too easy!

// context is an instance of ClientContext// use CSOM for both SharePoint Online and SharePoint 2013 WithRootSharePointContext(context =>{WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// create numage package manager within current SharePoint contextvarpackageManager=newSPMeta2SolutionPackageManager(nuGetGalleryRepository,context);// setup provision servicespackageManager.ProvisionService=newStandardCSOMProvisionService();// but you can also setup SSOM based provision service as following//packageManager.ProvisionService = new StandardSSOMProvisionService();// set the provision host // CSOM -> ClientContext// SSOM - either SPSite or SPWebpackageManager.ProvisionServiceHost=context;// just for tracing / loggingpackageManager.ProvisionService.OnModelNodeProcessed+=(sender,args)=>{Trace.WriteLine(string.Format(" Processed: [{0}/{1}] - [{2}%] - [{3}] [{4}]",newobject[]{args.ProcessedModelNodeCount,args.TotalModelNodeCount,100d*(double)args.ProcessedModelNodeCount/(double)args.TotalModelNodeCount,args.CurrentNode.Value.GetType().Name,args.CurrentNode.Value}));};// go fo install!packageManager.InstallPackage(nuGetPackage,true,false);});});

We have more samples as unit tests here, check them out:

Feature requests, support and contributions

In case you have unexpected issues or keen to see new features please contact support on SPMeta2 Yammer or here at github:

About

The package manager for SPMeta2 based SharePoint customizations.

Resources

Readme
Activity

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
MetaPack
The package manager for SPMeta2 based SharePoint customizations.
Deploying, updating and managing SharePoint customizations takes effort. Not only deployment but also versioning, modularization and dependency management require too much effort slowing down development, expanding cost and the delivery dates. Time spent on writing plumbing code, scripts or other means to handle all these areas should be spend on really important things.
MetaPack introduces a complete solution for packaging, versioning, deploying and updating SPMeta2 based customizations. It is built on top of NuGet platform and offers a smooth API for developers, a CLI for better CI/CD scenarios and a handy GUI app for IT-pros.
Here is how we see it working - develop model in Visual Studio, package and push to NuGet, consume via API later on
MetaPack Vision
Link to the full image
Build status
Build status
MetaPack in details
Introduces solution packaging
Packaging SharePoint customization is never an easy task. Should it be console app? Should it be provider hosted app? A PowerShell script?
Don't worry. MetaPack packages your solution as a self-contained NuGet package. As simple as that.
Handles solution versioning
Version history is another pain point while delivering SharePoint customizations. It is not easy to keep track of all customizations deployed not to talk about versioning them.
MetaPack uses NuGet Gallery infrastructure to provide solution version tracking. Semantic versioning naturally comes along.
Makes dependency management possible
Did you ever want to reuse and modularize your customizations so that you can compose bigger building blocks? We know it's hard to implement.
MetaPack brings the best of NuGet platform: package dependency management, versioning and easy modularization.
Simplifies deployment and updates
Solution life-cycle does not end with the first deployment. New features are built, new versions are released so that a smooth update process is a must.
MetaPack offers the best experience ever to deploy and update your models. It handles all the details and even shows if updates are available.
Offers API, a CLI and user friendly GUI
Modern software development blurs the boundaries between developers, IT-pros and business. Team needs to work closely having a solid, smooth delivery workflow.
MetaPack offers ultimate experience for all team: developers leverage API, IT-pros have a CLI and business have a friendly GUI based application.
Improves CI/CD story
Ultimately, MetaPack not only helps to ship SharePoint customizations to the client but also helps to improve continues integration and deployment story.
Create SPMeta2 models in Visual Studios, use API to create NuGet packages, ship them the way you like: API, CLI or GUI - it's all yours.
As for the API, that's how you can push your SPMeta2 models into NuGet Gallery:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);});
Next, you can get package from the NuGet Gallery and unpack it:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// unpacking the solutionusing(varstreamReader=nuGetPackage.GetStream()){// here is your solution with all the modelsvarunpackedSolutionPackage=packagingService.Unpack(streamReader)asSPMeta2SolutionPackage;// do something with the solutionforeach(varmodelinunpackedSolutionPackage.Models){// do some stuff with models// deploy the way you like? }}});
But why not to deploy your solution straight to SharePoint? Too easy!
// context is an instance of ClientContext// use CSOM for both SharePoint Online and SharePoint 2013 WithRootSharePointContext(context =>{WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// create numage package manager within current SharePoint contextvarpackageManager=newSPMeta2SolutionPackageManager(nuGetGalleryRepository,context);// setup provision servicespackageManager.ProvisionService=newStandardCSOMProvisionService();// but you can also setup SSOM based provision service as following//packageManager.ProvisionService = new StandardSSOMProvisionService();// set the provision host // CSOM -> ClientContext// SSOM - either SPSite or SPWebpackageManager.ProvisionServiceHost=context;// just for tracing / loggingpackageManager.ProvisionService.OnModelNodeProcessed+=(sender,args)=>{Trace.WriteLine(string.Format(" Processed: [{0}/{1}] - [{2}%] - [{3}] [{4}]",newobject[]{args.ProcessedModelNodeCount,args.TotalModelNodeCount,100d*(double)args.ProcessedModelNodeCount/(double)args.TotalModelNodeCount,args.CurrentNode.Value.GetType().Name,args.CurrentNode.Value}));};// go fo install!packageManager.InstallPackage(nuGetPackage,true,false);});});
We have more samples as unit tests here, check them out:
Feature requests, support and contributions
In case you have unexpected issues or keen to see new features please contact support on SPMeta2 Yammer or here at github:
About
The package manager for SPMeta2 based SharePoint customizations.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
MetaPack
The package manager for SPMeta2 based SharePoint customizations.
Deploying, updating and managing SharePoint customizations takes effort. Not only deployment but also versioning, modularization and dependency management require too much effort slowing down development, expanding cost and the delivery dates. Time spent on writing plumbing code, scripts or other means to handle all these areas should be spend on really important things.
MetaPack introduces a complete solution for packaging, versioning, deploying and updating SPMeta2 based customizations. It is built on top of NuGet platform and offers a smooth API for developers, a CLI for better CI/CD scenarios and a handy GUI app for IT-pros.
Here is how we see it working - develop model in Visual Studio, package and push to NuGet, consume via API later on
MetaPack Vision
Link to the full image
Build status
Build status
MetaPack in details
Introduces solution packaging
Packaging SharePoint customization is never an easy task. Should it be console app? Should it be provider hosted app? A PowerShell script?
Don't worry. MetaPack packages your solution as a self-contained NuGet package. As simple as that.
Handles solution versioning
Version history is another pain point while delivering SharePoint customizations. It is not easy to keep track of all customizations deployed not to talk about versioning them.
MetaPack uses NuGet Gallery infrastructure to provide solution version tracking. Semantic versioning naturally comes along.
Makes dependency management possible
Did you ever want to reuse and modularize your customizations so that you can compose bigger building blocks? We know it's hard to implement.
MetaPack brings the best of NuGet platform: package dependency management, versioning and easy modularization.
Simplifies deployment and updates
Solution life-cycle does not end with the first deployment. New features are built, new versions are released so that a smooth update process is a must.
MetaPack offers the best experience ever to deploy and update your models. It handles all the details and even shows if updates are available.
Offers API, a CLI and user friendly GUI
Modern software development blurs the boundaries between developers, IT-pros and business. Team needs to work closely having a solid, smooth delivery workflow.
MetaPack offers ultimate experience for all team: developers leverage API, IT-pros have a CLI and business have a friendly GUI based application.
Improves CI/CD story
Ultimately, MetaPack not only helps to ship SharePoint customizations to the client but also helps to improve continues integration and deployment story.
Create SPMeta2 models in Visual Studios, use API to create NuGet packages, ship them the way you like: API, CLI or GUI - it's all yours.
As for the API, that's how you can push your SPMeta2 models into NuGet Gallery:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);});
Next, you can get package from the NuGet Gallery and unpack it:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// unpacking the solutionusing(varstreamReader=nuGetPackage.GetStream()){// here is your solution with all the modelsvarunpackedSolutionPackage=packagingService.Unpack(streamReader)asSPMeta2SolutionPackage;// do something with the solutionforeach(varmodelinunpackedSolutionPackage.Models){// do some stuff with models// deploy the way you like? }}});
But why not to deploy your solution straight to SharePoint? Too easy!
// context is an instance of ClientContext// use CSOM for both SharePoint Online and SharePoint 2013 WithRootSharePointContext(context =>{WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// create numage package manager within current SharePoint contextvarpackageManager=newSPMeta2SolutionPackageManager(nuGetGalleryRepository,context);// setup provision servicespackageManager.ProvisionService=newStandardCSOMProvisionService();// but you can also setup SSOM based provision service as following//packageManager.ProvisionService = new StandardSSOMProvisionService();// set the provision host // CSOM -> ClientContext// SSOM - either SPSite or SPWebpackageManager.ProvisionServiceHost=context;// just for tracing / loggingpackageManager.ProvisionService.OnModelNodeProcessed+=(sender,args)=>{Trace.WriteLine(string.Format(" Processed: [{0}/{1}] - [{2}%] - [{3}] [{4}]",newobject[]{args.ProcessedModelNodeCount,args.TotalModelNodeCount,100d*(double)args.ProcessedModelNodeCount/(double)args.TotalModelNodeCount,args.CurrentNode.Value.GetType().Name,args.CurrentNode.Value}));};// go fo install!packageManager.InstallPackage(nuGetPackage,true,false);});});
We have more samples as unit tests here, check them out:
Feature requests, support and contributions
In case you have unexpected issues or keen to see new features please contact support on SPMeta2 Yammer or here at github:
About
The package manager for SPMeta2 based SharePoint customizations.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
MetaPack
The package manager for SPMeta2 based SharePoint customizations.
Deploying, updating and managing SharePoint customizations takes effort. Not only deployment but also versioning, modularization and dependency management require too much effort slowing down development, expanding cost and the delivery dates. Time spent on writing plumbing code, scripts or other means to handle all these areas should be spend on really important things.
MetaPack introduces a complete solution for packaging, versioning, deploying and updating SPMeta2 based customizations. It is built on top of NuGet platform and offers a smooth API for developers, a CLI for better CI/CD scenarios and a handy GUI app for IT-pros.
Here is how we see it working - develop model in Visual Studio, package and push to NuGet, consume via API later on
MetaPack Vision
Link to the full image
Build status
Build status
MetaPack in details
Introduces solution packaging
Packaging SharePoint customization is never an easy task. Should it be console app? Should it be provider hosted app? A PowerShell script?
Don't worry. MetaPack packages your solution as a self-contained NuGet package. As simple as that.
Handles solution versioning
Version history is another pain point while delivering SharePoint customizations. It is not easy to keep track of all customizations deployed not to talk about versioning them.
MetaPack uses NuGet Gallery infrastructure to provide solution version tracking. Semantic versioning naturally comes along.
Makes dependency management possible
Did you ever want to reuse and modularize your customizations so that you can compose bigger building blocks? We know it's hard to implement.
MetaPack brings the best of NuGet platform: package dependency management, versioning and easy modularization.
Simplifies deployment and updates
Solution life-cycle does not end with the first deployment. New features are built, new versions are released so that a smooth update process is a must.
MetaPack offers the best experience ever to deploy and update your models. It handles all the details and even shows if updates are available.
Offers API, a CLI and user friendly GUI
Modern software development blurs the boundaries between developers, IT-pros and business. Team needs to work closely having a solid, smooth delivery workflow.
MetaPack offers ultimate experience for all team: developers leverage API, IT-pros have a CLI and business have a friendly GUI based application.
Improves CI/CD story
Ultimately, MetaPack not only helps to ship SharePoint customizations to the client but also helps to improve continues integration and deployment story.
Create SPMeta2 models in Visual Studios, use API to create NuGet packages, ship them the way you like: API, CLI or GUI - it's all yours.
As for the API, that's how you can push your SPMeta2 models into NuGet Gallery:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);});
Next, you can get package from the NuGet Gallery and unpack it:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// unpacking the solutionusing(varstreamReader=nuGetPackage.GetStream()){// here is your solution with all the modelsvarunpackedSolutionPackage=packagingService.Unpack(streamReader)asSPMeta2SolutionPackage;// do something with the solutionforeach(varmodelinunpackedSolutionPackage.Models){// do some stuff with models// deploy the way you like? }}});
But why not to deploy your solution straight to SharePoint? Too easy!
// context is an instance of ClientContext// use CSOM for both SharePoint Online and SharePoint 2013 WithRootSharePointContext(context =>{WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// create numage package manager within current SharePoint contextvarpackageManager=newSPMeta2SolutionPackageManager(nuGetGalleryRepository,context);// setup provision servicespackageManager.ProvisionService=newStandardCSOMProvisionService();// but you can also setup SSOM based provision service as following//packageManager.ProvisionService = new StandardSSOMProvisionService();// set the provision host // CSOM -> ClientContext// SSOM - either SPSite or SPWebpackageManager.ProvisionServiceHost=context;// just for tracing / loggingpackageManager.ProvisionService.OnModelNodeProcessed+=(sender,args)=>{Trace.WriteLine(string.Format(" Processed: [{0}/{1}] - [{2}%] - [{3}] [{4}]",newobject[]{args.ProcessedModelNodeCount,args.TotalModelNodeCount,100d*(double)args.ProcessedModelNodeCount/(double)args.TotalModelNodeCount,args.CurrentNode.Value.GetType().Name,args.CurrentNode.Value}));};// go fo install!packageManager.InstallPackage(nuGetPackage,true,false);});});
We have more samples as unit tests here, check them out:
Feature requests, support and contributions
In case you have unexpected issues or keen to see new features please contact support on SPMeta2 Yammer or here at github:
About
The package manager for SPMeta2 based SharePoint customizations.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
MetaPack
The package manager for SPMeta2 based SharePoint customizations.
Deploying, updating and managing SharePoint customizations takes effort. Not only deployment but also versioning, modularization and dependency management require too much effort slowing down development, expanding cost and the delivery dates. Time spent on writing plumbing code, scripts or other means to handle all these areas should be spend on really important things.
MetaPack introduces a complete solution for packaging, versioning, deploying and updating SPMeta2 based customizations. It is built on top of NuGet platform and offers a smooth API for developers, a CLI for better CI/CD scenarios and a handy GUI app for IT-pros.
Here is how we see it working - develop model in Visual Studio, package and push to NuGet, consume via API later on
MetaPack Vision
Link to the full image
Build status
Build status
MetaPack in details
Introduces solution packaging
Packaging SharePoint customization is never an easy task. Should it be console app? Should it be provider hosted app? A PowerShell script?
Don't worry. MetaPack packages your solution as a self-contained NuGet package. As simple as that.
Handles solution versioning
Version history is another pain point while delivering SharePoint customizations. It is not easy to keep track of all customizations deployed not to talk about versioning them.
MetaPack uses NuGet Gallery infrastructure to provide solution version tracking. Semantic versioning naturally comes along.
Makes dependency management possible
Did you ever want to reuse and modularize your customizations so that you can compose bigger building blocks? We know it's hard to implement.
MetaPack brings the best of NuGet platform: package dependency management, versioning and easy modularization.
Simplifies deployment and updates
Solution life-cycle does not end with the first deployment. New features are built, new versions are released so that a smooth update process is a must.
MetaPack offers the best experience ever to deploy and update your models. It handles all the details and even shows if updates are available.
Offers API, a CLI and user friendly GUI
Modern software development blurs the boundaries between developers, IT-pros and business. Team needs to work closely having a solid, smooth delivery workflow.
MetaPack offers ultimate experience for all team: developers leverage API, IT-pros have a CLI and business have a friendly GUI based application.
Improves CI/CD story
Ultimately, MetaPack not only helps to ship SharePoint customizations to the client but also helps to improve continues integration and deployment story.
Create SPMeta2 models in Visual Studios, use API to create NuGet packages, ship them the way you like: API, CLI or GUI - it's all yours.
As for the API, that's how you can push your SPMeta2 models into NuGet Gallery:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);});
Next, you can get package from the NuGet Gallery and unpack it:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// unpacking the solutionusing(varstreamReader=nuGetPackage.GetStream()){// here is your solution with all the modelsvarunpackedSolutionPackage=packagingService.Unpack(streamReader)asSPMeta2SolutionPackage;// do something with the solutionforeach(varmodelinunpackedSolutionPackage.Models){// do some stuff with models// deploy the way you like? }}});
But why not to deploy your solution straight to SharePoint? Too easy!
// context is an instance of ClientContext// use CSOM for both SharePoint Online and SharePoint 2013 WithRootSharePointContext(context =>{WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// create numage package manager within current SharePoint contextvarpackageManager=newSPMeta2SolutionPackageManager(nuGetGalleryRepository,context);// setup provision servicespackageManager.ProvisionService=newStandardCSOMProvisionService();// but you can also setup SSOM based provision service as following//packageManager.ProvisionService = new StandardSSOMProvisionService();// set the provision host // CSOM -> ClientContext// SSOM - either SPSite or SPWebpackageManager.ProvisionServiceHost=context;// just for tracing / loggingpackageManager.ProvisionService.OnModelNodeProcessed+=(sender,args)=>{Trace.WriteLine(string.Format(" Processed: [{0}/{1}] - [{2}%] - [{3}] [{4}]",newobject[]{args.ProcessedModelNodeCount,args.TotalModelNodeCount,100d*(double)args.ProcessedModelNodeCount/(double)args.TotalModelNodeCount,args.CurrentNode.Value.GetType().Name,args.CurrentNode.Value}));};// go fo install!packageManager.InstallPackage(nuGetPackage,true,false);});});
We have more samples as unit tests here, check them out:
Feature requests, support and contributions
In case you have unexpected issues or keen to see new features please contact support on SPMeta2 Yammer or here at github:
About
The package manager for SPMeta2 based SharePoint customizations.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
MetaPack
The package manager for SPMeta2 based SharePoint customizations.
Deploying, updating and managing SharePoint customizations takes effort. Not only deployment but also versioning, modularization and dependency management require too much effort slowing down development, expanding cost and the delivery dates. Time spent on writing plumbing code, scripts or other means to handle all these areas should be spend on really important things.
MetaPack introduces a complete solution for packaging, versioning, deploying and updating SPMeta2 based customizations. It is built on top of NuGet platform and offers a smooth API for developers, a CLI for better CI/CD scenarios and a handy GUI app for IT-pros.
Here is how we see it working - develop model in Visual Studio, package and push to NuGet, consume via API later on
MetaPack Vision
Link to the full image
Build status
Build status
MetaPack in details
Introduces solution packaging
Packaging SharePoint customization is never an easy task. Should it be console app? Should it be provider hosted app? A PowerShell script?
Don't worry. MetaPack packages your solution as a self-contained NuGet package. As simple as that.
Handles solution versioning
Version history is another pain point while delivering SharePoint customizations. It is not easy to keep track of all customizations deployed not to talk about versioning them.
MetaPack uses NuGet Gallery infrastructure to provide solution version tracking. Semantic versioning naturally comes along.
Makes dependency management possible
Did you ever want to reuse and modularize your customizations so that you can compose bigger building blocks? We know it's hard to implement.
MetaPack brings the best of NuGet platform: package dependency management, versioning and easy modularization.
Simplifies deployment and updates
Solution life-cycle does not end with the first deployment. New features are built, new versions are released so that a smooth update process is a must.
MetaPack offers the best experience ever to deploy and update your models. It handles all the details and even shows if updates are available.
Offers API, a CLI and user friendly GUI
Modern software development blurs the boundaries between developers, IT-pros and business. Team needs to work closely having a solid, smooth delivery workflow.
MetaPack offers ultimate experience for all team: developers leverage API, IT-pros have a CLI and business have a friendly GUI based application.
Improves CI/CD story
Ultimately, MetaPack not only helps to ship SharePoint customizations to the client but also helps to improve continues integration and deployment story.
Create SPMeta2 models in Visual Studios, use API to create NuGet packages, ship them the way you like: API, CLI or GUI - it's all yours.
As for the API, that's how you can push your SPMeta2 models into NuGet Gallery:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);});
Next, you can get package from the NuGet Gallery and unpack it:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// unpacking the solutionusing(varstreamReader=nuGetPackage.GetStream()){// here is your solution with all the modelsvarunpackedSolutionPackage=packagingService.Unpack(streamReader)asSPMeta2SolutionPackage;// do something with the solutionforeach(varmodelinunpackedSolutionPackage.Models){// do some stuff with models// deploy the way you like? }}});
But why not to deploy your solution straight to SharePoint? Too easy!
// context is an instance of ClientContext// use CSOM for both SharePoint Online and SharePoint 2013 WithRootSharePointContext(context =>{WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// create numage package manager within current SharePoint contextvarpackageManager=newSPMeta2SolutionPackageManager(nuGetGalleryRepository,context);// setup provision servicespackageManager.ProvisionService=newStandardCSOMProvisionService();// but you can also setup SSOM based provision service as following//packageManager.ProvisionService = new StandardSSOMProvisionService();// set the provision host // CSOM -> ClientContext// SSOM - either SPSite or SPWebpackageManager.ProvisionServiceHost=context;// just for tracing / loggingpackageManager.ProvisionService.OnModelNodeProcessed+=(sender,args)=>{Trace.WriteLine(string.Format(" Processed: [{0}/{1}] - [{2}%] - [{3}] [{4}]",newobject[]{args.ProcessedModelNodeCount,args.TotalModelNodeCount,100d*(double)args.ProcessedModelNodeCount/(double)args.TotalModelNodeCount,args.CurrentNode.Value.GetType().Name,args.CurrentNode.Value}));};// go fo install!packageManager.InstallPackage(nuGetPackage,true,false);});});
We have more samples as unit tests here, check them out:
Feature requests, support and contributions
In case you have unexpected issues or keen to see new features please contact support on SPMeta2 Yammer or here at github:
About
The package manager for SPMeta2 based SharePoint customizations.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
MetaPack
The package manager for SPMeta2 based SharePoint customizations.
Deploying, updating and managing SharePoint customizations takes effort. Not only deployment but also versioning, modularization and dependency management require too much effort slowing down development, expanding cost and the delivery dates. Time spent on writing plumbing code, scripts or other means to handle all these areas should be spend on really important things.
MetaPack introduces a complete solution for packaging, versioning, deploying and updating SPMeta2 based customizations. It is built on top of NuGet platform and offers a smooth API for developers, a CLI for better CI/CD scenarios and a handy GUI app for IT-pros.
Here is how we see it working - develop model in Visual Studio, package and push to NuGet, consume via API later on
MetaPack Vision
Link to the full image
Build status
Build status
MetaPack in details
Introduces solution packaging
Packaging SharePoint customization is never an easy task. Should it be console app? Should it be provider hosted app? A PowerShell script?
Don't worry. MetaPack packages your solution as a self-contained NuGet package. As simple as that.
Handles solution versioning
Version history is another pain point while delivering SharePoint customizations. It is not easy to keep track of all customizations deployed not to talk about versioning them.
MetaPack uses NuGet Gallery infrastructure to provide solution version tracking. Semantic versioning naturally comes along.
Makes dependency management possible
Did you ever want to reuse and modularize your customizations so that you can compose bigger building blocks? We know it's hard to implement.
MetaPack brings the best of NuGet platform: package dependency management, versioning and easy modularization.
Simplifies deployment and updates
Solution life-cycle does not end with the first deployment. New features are built, new versions are released so that a smooth update process is a must.
MetaPack offers the best experience ever to deploy and update your models. It handles all the details and even shows if updates are available.
Offers API, a CLI and user friendly GUI
Modern software development blurs the boundaries between developers, IT-pros and business. Team needs to work closely having a solid, smooth delivery workflow.
MetaPack offers ultimate experience for all team: developers leverage API, IT-pros have a CLI and business have a friendly GUI based application.
Improves CI/CD story
Ultimately, MetaPack not only helps to ship SharePoint customizations to the client but also helps to improve continues integration and deployment story.
Create SPMeta2 models in Visual Studios, use API to create NuGet packages, ship them the way you like: API, CLI or GUI - it's all yours.
As for the API, that's how you can push your SPMeta2 models into NuGet Gallery:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);});
Next, you can get package from the NuGet Gallery and unpack it:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// unpacking the solutionusing(varstreamReader=nuGetPackage.GetStream()){// here is your solution with all the modelsvarunpackedSolutionPackage=packagingService.Unpack(streamReader)asSPMeta2SolutionPackage;// do something with the solutionforeach(varmodelinunpackedSolutionPackage.Models){// do some stuff with models// deploy the way you like? }}});
But why not to deploy your solution straight to SharePoint? Too easy!
// context is an instance of ClientContext// use CSOM for both SharePoint Online and SharePoint 2013 WithRootSharePointContext(context =>{WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// create numage package manager within current SharePoint contextvarpackageManager=newSPMeta2SolutionPackageManager(nuGetGalleryRepository,context);// setup provision servicespackageManager.ProvisionService=newStandardCSOMProvisionService();// but you can also setup SSOM based provision service as following//packageManager.ProvisionService = new StandardSSOMProvisionService();// set the provision host // CSOM -> ClientContext// SSOM - either SPSite or SPWebpackageManager.ProvisionServiceHost=context;// just for tracing / loggingpackageManager.ProvisionService.OnModelNodeProcessed+=(sender,args)=>{Trace.WriteLine(string.Format(" Processed: [{0}/{1}] - [{2}%] - [{3}] [{4}]",newobject[]{args.ProcessedModelNodeCount,args.TotalModelNodeCount,100d*(double)args.ProcessedModelNodeCount/(double)args.TotalModelNodeCount,args.CurrentNode.Value.GetType().Name,args.CurrentNode.Value}));};// go fo install!packageManager.InstallPackage(nuGetPackage,true,false);});});
We have more samples as unit tests here, check them out:
Feature requests, support and contributions
In case you have unexpected issues or keen to see new features please contact support on SPMeta2 Yammer or here at github:
About
The package manager for SPMeta2 based SharePoint customizations.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
MetaPack
The package manager for SPMeta2 based SharePoint customizations.
Deploying, updating and managing SharePoint customizations takes effort. Not only deployment but also versioning, modularization and dependency management require too much effort slowing down development, expanding cost and the delivery dates. Time spent on writing plumbing code, scripts or other means to handle all these areas should be spend on really important things.
MetaPack introduces a complete solution for packaging, versioning, deploying and updating SPMeta2 based customizations. It is built on top of NuGet platform and offers a smooth API for developers, a CLI for better CI/CD scenarios and a handy GUI app for IT-pros.
Here is how we see it working - develop model in Visual Studio, package and push to NuGet, consume via API later on
MetaPack Vision
Link to the full image
Build status
Build status
MetaPack in details
Introduces solution packaging
Packaging SharePoint customization is never an easy task. Should it be console app? Should it be provider hosted app? A PowerShell script?
Don't worry. MetaPack packages your solution as a self-contained NuGet package. As simple as that.
Handles solution versioning
Version history is another pain point while delivering SharePoint customizations. It is not easy to keep track of all customizations deployed not to talk about versioning them.
MetaPack uses NuGet Gallery infrastructure to provide solution version tracking. Semantic versioning naturally comes along.
Makes dependency management possible
Did you ever want to reuse and modularize your customizations so that you can compose bigger building blocks? We know it's hard to implement.
MetaPack brings the best of NuGet platform: package dependency management, versioning and easy modularization.
Simplifies deployment and updates
Solution life-cycle does not end with the first deployment. New features are built, new versions are released so that a smooth update process is a must.
MetaPack offers the best experience ever to deploy and update your models. It handles all the details and even shows if updates are available.
Offers API, a CLI and user friendly GUI
Modern software development blurs the boundaries between developers, IT-pros and business. Team needs to work closely having a solid, smooth delivery workflow.
MetaPack offers ultimate experience for all team: developers leverage API, IT-pros have a CLI and business have a friendly GUI based application.
Improves CI/CD story
Ultimately, MetaPack not only helps to ship SharePoint customizations to the client but also helps to improve continues integration and deployment story.
Create SPMeta2 models in Visual Studios, use API to create NuGet packages, ship them the way you like: API, CLI or GUI - it's all yours.
As for the API, that's how you can push your SPMeta2 models into NuGet Gallery:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);});
Next, you can get package from the NuGet Gallery and unpack it:
WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// unpacking the solutionusing(varstreamReader=nuGetPackage.GetStream()){// here is your solution with all the modelsvarunpackedSolutionPackage=packagingService.Unpack(streamReader)asSPMeta2SolutionPackage;// do something with the solutionforeach(varmodelinunpackedSolutionPackage.Models){// do some stuff with models// deploy the way you like? }}});
But why not to deploy your solution straight to SharePoint? Too easy!
// context is an instance of ClientContext// use CSOM for both SharePoint Online and SharePoint 2013 WithRootSharePointContext(context =>{WithNuGetContext((apiUrl,apiKey,repoUrl)=>{// you need to apiUrl / apiKey for your NuGet Gallery// apiUrl - something like 'https://{your-nuget-gallery}/api/v2'// apiKey - a long GUID in your NuGet Gallery profile// also, https://www.myget.org might help to get started// create package service instancevarpackagingService=newSPMeta2SolutionPackageService();// create SPMeta2 solution packagevarsolutionPackage=newSPMeta2SolutionPackage();solutionPackage.Title="SPMeta2 CI Package";solutionPackage.Id="SPMeta2.CI";solutionPackage.Version="1.0.0.0";solutionPackage.Authors="SubPoint Solutions";solutionPackage.Description="A test package for SPMeta1 models.";// add some modelsvarmodels=newModelNode[]{SPMeta2Model.NewSiteModel(site =>{}),SPMeta2Model.NewWebModel(web =>{}),};foreach(varmodelinmodels){solutionPackage.Models.Add(model);}// we increment solution version within current testUpdatePackageVersion(solutionPackage);// publish your solution into NuGet GallerypackagingService.Push(solutionPackage,apiUrl,apiKey);// get package from the NuGet Gallery// we use an extension method to find package, as NuGet Gallery takes time to refresh the cache// get the packagevarnuGetGalleryRepository=PackageRepositoryFactory.Default.CreateRepository(repoUrl);varnuGetPackage=nuGetGalleryRepository.FindPackageSafe(solutionPackage.Id,newSemanticVersion(solutionPackage.Version));// create numage package manager within current SharePoint contextvarpackageManager=newSPMeta2SolutionPackageManager(nuGetGalleryRepository,context);// setup provision servicespackageManager.ProvisionService=newStandardCSOMProvisionService();// but you can also setup SSOM based provision service as following//packageManager.ProvisionService = new StandardSSOMProvisionService();// set the provision host // CSOM -> ClientContext// SSOM - either SPSite or SPWebpackageManager.ProvisionServiceHost=context;// just for tracing / loggingpackageManager.ProvisionService.OnModelNodeProcessed+=(sender,args)=>{Trace.WriteLine(string.Format(" Processed: [{0}/{1}] - [{2}%] - [{3}] [{4}]",newobject[]{args.ProcessedModelNodeCount,args.TotalModelNodeCount,100d*(double)args.ProcessedModelNodeCount/(double)args.TotalModelNodeCount,args.CurrentNode.Value.GetType().Name,args.CurrentNode.Value}));};// go fo install!packageManager.InstallPackage(nuGetPackage,true,false);});});
We have more samples as unit tests here, check them out:
Feature requests, support and contributions
In case you have unexpected issues or keen to see new features please contact support on SPMeta2 Yammer or here at github:
About
The package manager for SPMeta2 based SharePoint customizations.
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages