public ExtensionEntry GetData()
{
ExtensionEntry data = new ExtensionEntry();
ObjectSupport.CopyData(this, data);
return(data);
}
public void Setup()
{
_logFile = Path.Combine(Path.GetTempPath(), "logfile.json");
_entry = new ExtensionEntry {
Id = "id"
};
_registry = new StaticRegistryKey();
}
void AddExtensionEntry(Type extendedItemType, ExtensionEntry entry)
{
List<ExtensionEntry> list;
if (!_extensions.TryGetValue(extendedItemType, out list)) {
list = _extensions[extendedItemType] = new List<ExtensionEntry>();
}
list.Add(entry);
}
void AddExtensionEntry(Type extendedItemType, ExtensionEntry entry)
{
List <ExtensionEntry> list;
if (!_extensions.TryGetValue(extendedItemType, out list))
{
list = _extensions[extendedItemType] = new List <ExtensionEntry>();
}
list.Add(entry);
}
public static IDictionary <String, ExtensionEntry> GetExtensions(this IEnumerable <MethodInfo> methods)
{
var entries = new Dictionary <String, ExtensionEntry>();
foreach (var method in methods)
{
var names = method.GetCustomAttributes <DomNameAttribute>()
.Select(m => m.OfficialName);
var accessors = method.GetCustomAttributes <DomAccessorAttribute>()
.Select(m => m.Type);
var forward = method.GetCustomAttribute <DomPutForwardsAttribute>();
foreach (var name in names)
{
if (!entries.TryGetValue(name, out var entry))
{
entry = new ExtensionEntry
{
Forward = forward,
};
entries.Add(name, entry);
}
if (accessors.Any())
{
var accessor = accessors.FirstOrDefault();
switch (accessor)
{
case Accessors.Setter:
entry.Setter = method;
break;
case Accessors.Getter:
entry.Getter = method;
break;
case Accessors.Remover:
entry.Remover = method;
break;
case Accessors.Adder:
entry.Adder = method;
break;
}
}
else
{
entry.Other = method;
}
}
}
return(entries);
}
public async Task <ActionResult> EditExtension(string extension)
{
using (ExtensionEntryDataProvider dataProvider = new ExtensionEntryDataProvider()) {
EditModel model = new EditModel {
};
ExtensionEntry data = await dataProvider.GetItemAsync(extension);
if (data == null)
{
throw new Error(this.__ResStr("notFound", "Extension \"{0}\" not found"), extension);
}
model.SetData(data);
Module.Title = this.__ResStr("modTitle", "Extension \"{0}\"", extension);
return(View(model));
}
}
public async Task <ActionResult> EditExtension_Partial(EditModel model)
{
string originalExtension = model.OriginalExtension;
using (ExtensionEntryDataProvider dataProvider = new ExtensionEntryDataProvider()) {
ExtensionEntry data = await dataProvider.GetItemAsync(originalExtension);// get the original item
if (data == null)
{
ModelState.AddModelError("Extension", this.__ResStr("alreadyDeleted", "Extension {0} has been removed and can no longer be updated", originalExtension));
return(PartialView(model));
}
ObjectSupport.CopyData(data, model, ReadOnly: true); // update read only properties in model in case there is an error
if (!ModelState.IsValid)
{
return(PartialView(model));
}
data = model.GetData(data); // merge new data into original
model.SetData(data); // and all the data back into model for final display
switch (await dataProvider.UpdateItemAsync(data))
{
default:
case UpdateStatusEnum.RecordDeleted:
ModelState.AddModelError("Name", this.__ResStr("alreadyDeleted", "Extension {0} has been removed and can no longer be updated", model.OriginalExtension));
return(PartialView(model));
case UpdateStatusEnum.NewKeyExists:
ModelState.AddModelError("Name", this.__ResStr("alreadyExists", "Extension {0} already exists.", data.Extension));
return(PartialView(model));
case UpdateStatusEnum.OK:
break;
}
return(FormProcessed(model, this.__ResStr("okSaved", "Extension saved"), OnPopupClose: OnPopupCloseEnum.ReloadModule));
}
}
public void InstallPackages(string _extensionId, string _extensionName)
{
// IProgress<ServiceProgressData> _progress = new System.Progress<ServiceProgressData>();
// var task = InitializeAsync(new CancellationToken(false), _progress);
// Waits for MEF to initialize before the extension manager is ready to use
var scComponentModel = VSPackageInstaller.VSPackage.GetGlobalService(typeof(SComponentModel));
var repository = VSPackageInstaller.VSPackage.GetGlobalService(typeof(SVsExtensionRepository)) as IVsExtensionRepository;
var manager = VSPackageInstaller.VSPackage.GetGlobalService(typeof(SVsExtensionManager)) as IVsExtensionManager;
Version vsVersion = VsHelpers.GetVisualStudioVersion();
var registry = new RegistryKeyWrapper(VSPackageInstaller.VSPackage.thePackage.UserRegistryRoot);
WebEssentials.Installer installer = new WebEssentials.Installer();
ExtensionEntry extensionEntry = new ExtensionEntry
{
Id = _extensionId,
Name = _extensionName
};
installer.InstallExtension(extensionEntry, repository, manager);
}
public void SetData(ExtensionEntry data)
{
ObjectSupport.CopyData(data, this);
OriginalExtension = Extension;
}
public ExtensionEntry GetData(ExtensionEntry data)
{
ObjectSupport.CopyData(this, data);
return(data);
}
private void EnsureInitialized()
{
if (_isInitialized)
{
return;
}
lock (InitializationSyncLock)
{
if (_isInitialized)
{
return;
}
var modules = _applicationContext.Application.Modules;
var loadedExtensions = new ConcurrentDictionary <string, ExtensionEntry>();
// Load all extensions in parallel
Parallel.ForEach(modules, new ParallelOptions {
MaxDegreeOfParallelism = 8
}, (module) =>
{
if (!module.ModuleInfo.Exists)
{
return;
}
var manifestInfo = new ManifestInfo(module.ModuleInfo);
var extensionInfo = new ExtensionInfo(module.SubPath, manifestInfo, (mi, ei) => {
return(_featuresProvider.GetFeatures(ei, mi));
});
var entry = new ExtensionEntry
{
ExtensionInfo = extensionInfo,
Assembly = module.Assembly,
ExportedTypes = module.Assembly.ExportedTypes
};
loadedExtensions.TryAdd(module.Name, entry);
});
var loadedFeatures = new Dictionary <string, FeatureEntry>();
// Get all valid types from any extension
var allTypesByExtension = loadedExtensions.SelectMany(extension =>
extension.Value.ExportedTypes.Where(IsComponentType)
.Select(type => new
{
ExtensionEntry = extension.Value,
Type = type
})).ToArray();
var typesByFeature = allTypesByExtension
.GroupBy(typeByExtension => GetSourceFeatureNameForType(
typeByExtension.Type,
typeByExtension.ExtensionEntry.ExtensionInfo.Id))
.ToDictionary(
group => group.Key,
group => group.Select(typesByExtension => typesByExtension.Type).ToArray());
foreach (var loadedExtension in loadedExtensions)
{
var extension = loadedExtension.Value;
foreach (var feature in extension.ExtensionInfo.Features)
{
// Features can have no types
if (typesByFeature.TryGetValue(feature.Id, out var featureTypes))
{
foreach (var type in featureTypes)
{
_typeFeatureProvider.TryAdd(type, feature);
}
}
else
{
featureTypes = Array.Empty <Type>();
}
loadedFeatures.Add(feature.Id, new CompiledFeatureEntry(feature, featureTypes));
}
}
;
// Feature infos and entries are ordered by priority and dependencies.
_featureInfos = Order(loadedFeatures.Values.Select(f => f.FeatureInfo));
_features = _featureInfos.ToDictionary(f => f.Id, f => loadedFeatures[f.Id]);
// Extensions are also ordered according to the weight of their first features.
_extensionsInfos = _featureInfos.Where(f => f.Id == f.Extension.Features.First().Id)
.Select(f => f.Extension);
_extensions = _extensionsInfos.ToDictionary(e => e.Id, e => loadedExtensions[e.Id]);
_isInitialized = true;
}
}
public BrowseItem(BrowseExtensionsModule module, ExtensionEntry data)
{
Module = module;
ObjectSupport.CopyData(data, this);
}
