private static void GenerateExcelForMP(string[] args)
{
try
{
bool exportAlertGeneratingWorkflowsOnly = false;
ManagementPack mp = LoadManagementPack(args);
DatasetCreator datasetCreator = new DatasetCreator(mp);
ReportGenerator reportGenerator = new ReportGenerator(datasetCreator.Dataset, mp);
exportAlertGeneratingWorkflowsOnly = (args.Length == 3 && string.Compare(args[2], "AlertGeneratingWorkflowsOnly", true) == 0);
if (exportAlertGeneratingWorkflowsOnly)
{
Console.WriteLine("AlertGeneratingWorkflowsOnly command line switch doesn't work with Excel export, only HTML.");
}
reportGenerator.GenerateExcelReport(args[1]);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
}
/// <summary>
/// After prompting the user for approval, this method installs the Configuration override management pack.
/// </summary>
private void InstallConfigurationPack()
{
string tempFileName = Path.GetTempPath() + "Community.ManagementPackCatalog.Configuration.xml";
using (var resource = Assembly.GetExecutingAssembly().GetManifestResourceStream("Community.ManagementPackCatalog.UI.Community.ManagementPackCatalog.Configuration.xml"))
{
using (var file = new FileStream(tempFileName, FileMode.Create, FileAccess.Write))
{
resource.CopyTo(file);
}
}
configurationOverridePack = new ManagementPack(tempFileName);
ManagementGroupConnector.CurrentManagementGroup.ManagementPacks.ImportManagementPack(configurationOverridePack);
// Cleanup our temp stuff if we can
if (tempFileName != null)
{
try
{
File.Delete(tempFileName);
}
catch
{
// best effort
}
tempFileName = null;
}
}
public SMHandler()
{
String strSMServerName = null;
try
{
strSMServerName = Registry.GetValue("HKEY_CURRENT_USER\\Software\\Microsoft\\System Center\\2010\\Service Manager\\Console\\User Settings", "SDKServiceMachine", "localhost").ToString();
}
catch
{
Console.WriteLine("Cannot read the name of the SM Server from Registry.");
Environment.Exit(2);
}
try
{
mg = new EnterpriseManagementGroup(strSMServerName);
}
catch
{
Console.WriteLine("Cannot connect to SM Server {0}", strSMServerName);
Environment.Exit(2);
}
ManagementPack systemWorkitemMP = GetManagementPackByName("System.WorkItem.Library", this.mg);
wiClass = systemWorkitemMP.GetClass(WIType);
}
private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
//try
//{
GetSession();
mpCore = emg.GetManagementPack("SMCenter.AssetManagement.Core", "75b45bd6835084b1", new Version());
mpNA = emg.GetManagementPack("SMCenter.NetworkAssetManagement.Library", "75b45bd6835084b1", new Version());
classLocation = emg.EntityTypes.GetClass("SMCenter.Location", mpCore);
//classNetworkMap = emg.EntityTypes.GetClass("SMCenter.NetworkMap", mpNA);
relLoctoLoc = emg.EntityTypes.GetRelationshipClass("SMCenter.LocationContainsChildLocation", mpCore);
//Fill Templates
this.TemplateLocationItem.emg = emg;
this.TemplateLocationItem.PathString = "LinkedLocation";
this.TemplateLocationItem.mpClass = classLocation;
this.TemplateLocationItem.mpRelationshipClass = relLoctoLoc;
this.TemplateLocationItem.criteria = new EnterpriseManagementObjectCriteria("LocationType = '0A607435-3D34-23D1-B38E-B89DDE0A558D'", classLocation);
//////Handlers
this.AddHandler(FormEvents.SubmittedEvent, new EventHandler <FormCommandExecutedEventArgs>(this.OnSubmitted));
this.AddHandler(FormEvents.PreviewSubmitEvent, new EventHandler <PreviewFormCommandEventArgs>(this.OnPreviewSubmit));
//}
//catch (Exception ex)
//{
// System.Windows.MessageBox.Show(DateTime.Now + " : " + "UserControl_Loaded Error : " + ex.Message);
//}
}
//---------------------------------------------------------------------
private void AddDependencyIfNeeded()
{
ManagementPack workflowMP = m_mpWorkflow.Workflow.GetManagementPack();
bool addRefRequired = true;
if (workflowMP.Id == m_targetMp.Id)
{
//The workflow is defined in the same MP as the new override mp, no need to add dependency
addRefRequired = false;
}
else
{
foreach (KeyValuePair <string, ManagementPackReference> existingMPRef in m_targetMp.References)
{
if (existingMPRef.Value.KeyToken == workflowMP.KeyToken &&
existingMPRef.Value.Version == workflowMP.Version &&
existingMPRef.Value.Name == workflowMP.Name)
{
addRefRequired = false;
break;
}
}
}
if (addRefRequired)
{
ManagementPackReference mpRef = new ManagementPackReference(workflowMP);
m_targetMp.References.Add(workflowMP.Name, mpRef);
m_targetMp.AcceptChanges();
}
}
private void SetQueueStatus(Boolean bEnabled)
{
EnterpriseManagementGroup emg = new EnterpriseManagementGroup(txtManagementServer.Text);
//TODO: Switch this back to 'WorkItemGroup.%' Had to temporarily change this due to a bad naming convention in the code that has been fixed.
string strQueueDiscoveryCriteria = "Name LIKE '[cspi]%Discovery%'";
ManagementPackDiscoveryCriteria mpdc = new ManagementPackDiscoveryCriteria(strQueueDiscoveryCriteria);
IList <ManagementPackDiscovery> listDiscoveries = emg.Monitoring.GetDiscoveries(mpdc);
pbProgress.Value = 0;
pbProgress.Show();
double dDiscoveriesCount = listDiscoveries.Count;
double i = 0;
ManagementPack mp = null;
foreach (ManagementPackDiscovery discovery in listDiscoveries)
{
i++;
if (bEnabled == true)
{
discovery.Enabled = ManagementPackMonitoringLevel.@true;
}
else
{
discovery.Enabled = ManagementPackMonitoringLevel.@false;
}
discovery.Status = ManagementPackElementStatus.PendingUpdate;
mp = discovery.GetManagementPack();
double dComplete = i / dDiscoveriesCount * 100;
pbProgress.Value = (int)dComplete;
}
mp.AcceptChanges();
}
private void UpdateConnectorInstance()
{
//Get the server name to connect to and connect
String strServerName = Registry.GetValue("HKEY_CURRENT_USER\\Software\\Microsoft\\System Center\\2010\\Service Manager\\Console\\User Settings", "SDKServiceMachine", "localhost").ToString();
EnterpriseManagementGroup emg = new EnterpriseManagementGroup(strServerName);
//Get the Connectors MP and AA Connector Class
ManagementPack mpConnectors = emg.GetManagementPack("SCSM.AzureAutomation", "ac1fe0583b6c84af", new Version("1.0.0.0"));
ManagementPackClass classAAConnector = mpConnectors.GetClass("SCSM.AzureAutomation.Connector");
//Get the Connector object using the object ID
EnterpriseManagementObject emoAAConnector = emg.EntityObjects.GetObject <EnterpriseManagementObject>(this.EnterpriseManagementObjectID, ObjectQueryOptions.Default);
//Set the property values to the new values
emoAAConnector[classAAConnector, "DisplayName"].Value = this.DisplayName;
emoAAConnector[classAAConnector, "AutomationAccount"].Value = this.AutomationAccount;
emoAAConnector[classAAConnector, "SubscriptionID"].Value = this.SubscriptionID;
emoAAConnector[classAAConnector, "ResourceGroup"].Value = this.ResourceGroup;
emoAAConnector[classAAConnector, "RunAsAccountName"].Value = this.RunAsAccountName;
emoAAConnector[classAAConnector, "RunAsAccountPassword"].Value = this.RunAsAccountPassword;
emoAAConnector[classAAConnector, "RefreshIntervalHours"].Value = this.RefreshIntervalHours;
//Update Connector instance
emoAAConnector.Commit();
mpConnectors.AcceptChanges();
}
private void AddToCatalogWindow_Loaded(object sender, RoutedEventArgs e)
{
try
{
emg = GetSession();
if (emg == null)
{
emg = new EnterpriseManagementGroup("SM");
}
//mpAssetCore = emg.ManagementPacks.GetManagementPack("SMCenter.AssetManagement.Core", "75b45bd6835084b1", new Version());
mpSoftLibrary = emg.ManagementPacks.GetManagementPack("SMCenter.SoftwareAssetManagement.Library", "75b45bd6835084b1", new Version());
//mpSystemSoftwareLibrary = emg.ManagementPacks.GetManagementPack("System.Software.Library", "31bf3856ad364e35", new Version());
//classSoftwareItem = emg.EntityTypes.GetClass("System.SoftwareItem", mpSystemSoftwareLibrary);
classSoftwareTitle = emg.EntityTypes.GetClass("SMCenter.SoftwareTitle", mpSoftLibrary);
classSoftwareVersion = emg.EntityTypes.GetClass("SMCenter.SoftwareVersion", mpSoftLibrary);
//classPublisher = emg.EntityTypes.GetClass("SMCenter.Company", mpAssetCore);
//SMCenter.PublisherHasSoftwareTitle
//SMCenter.SoftwareTitleHasSoftwareVersion
//SMCenter.SoftwareVersionReferencesDiscoveredSoftwareItem
relSoftwareTitleHasSoftwareVersion = emg.EntityTypes.GetRelationshipClass("SMCenter.SoftwareTitleHasSoftwareVersion", mpSoftLibrary);
//relExcludedSoftwareItemGroup = emg.EntityTypes.GetRelationshipClass("SMCenter.ExcludedSoftwareItemGroupContainsEntities", mpSoftLibrary);
//TemplateSoftwareTitle.PathString = "SotwareTitle";
//TemplateSoftwareTitle.mpClass = classSoftwareTitle;
}
catch (Exception ex)
{
System.Windows.MessageBox.Show("Initialize procedure error : " + ex.Message, "Service Manager", MessageBoxButton.OK, MessageBoxImage.Error);
this.Close();
}
}
private static ManagementPack LoadManagementPack(string[] args)
{
ManagementPackBundle bundle;
ManagementPackFileStore store = Utilities.GetManagementPackStoreFromPath(args[0]);
ManagementPack mp;
if (System.IO.Path.GetExtension(args[0]).Equals(".mpb"))
{
ManagementPackBundleReader reader = ManagementPackBundleFactory.CreateBundleReader();
bundle = reader.Read(args[0], store);
// 1 at the time is ok
if (bundle.ManagementPacks.Count == 1)
{
mp = bundle.ManagementPacks[0];
return(mp);
}
else
{
// too many MPs contained in this MPB! - can onlhy open one at the time!
// do something sensible here
throw new ApplicationException("This MPB contains multiple MPs. " +
"In an upcoming version a dialog will open, asking you to choose which one you want to see. " +
"For now, we just are going to crash.");
}
}
else // we are dealing with an MP or XML - the old stuff works as it did for 2007
{
mp = new ManagementPack(args[0], store);
return(mp);
}
}
/// <summary>
/// Handles a request for the management pack properties
/// if the management pack is not installed the user is directed to the Website
/// </summary>
/// <param name="sender">Sending DataGrid</param>
/// <param name="args">Command Arguments</param>
protected override void OnPropertiesCommand(object sender, CommandEventArgs args)
{
base.OnPropertiesCommand(sender, args);
Cursor cursor = Cursor;
Cursor = Cursors.WaitCursor;
GitHubPackDetail gitHubPack = GridSelectedItem as GitHubPackDetail;
ManagementPack selectedMP = gitHubPack.InstalledManagementPack;
if (selectedMP == null)
{
string notificationMessage = string.Format(
"{0} is not currently installed.\nManagement Pack Properties are only available on installed packs.",
gitHubPack.ManagementPackSystemName);
DialogResult dialogResult = MessageBox.Show(notificationMessage, "This Management Pack is not currently installed.", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MPPropertiesData managementPackPropertiesData = new MPPropertiesData(selectedMP, ManagementGroup);
propertiesSheet = new MPSheet(Container, managementPackPropertiesData);
propertiesSheet.Show();
Cursor = cursor;
}
}
/// <summary>
/// 安装MP
/// </summary>
/// <param name="path">
/// The path.
/// </param>
public void InstallMp(string path)
{
var newMp = new ManagementPack(path);
var criteria = new ManagementPackCriteria($"Name = '{newMp.Name}'");
var oldMp = this.ManagementPacks.GetManagementPacks(criteria).FirstOrDefault();
if (oldMp != null)
{
// 已安装则跳过
HWLogger.Install.Warn($"Skip install：{oldMp.Name}-{oldMp.Version} has Installed.");
//// 已安装
// if (oldMp.Version != newMp.Version)
// {
// // 版本不一致则先进行卸载
// this.UnInstallMp(oldMp.Name);
// this.ManagementPacks.ImportManagementPack(newMp);
// Console.WriteLine($"Install {newMp.Name} Finish.");
// }
// else
// {
// HwLogger.Install.Warn($"Skip install：{newMp.Name}-{newMp.Version} has Installed.");
// }
}
else
{
this.ManagementPacks.ImportManagementPack(newMp);
HWLogger.Install.Warn($"Install {newMp.Name} Finish.");
}
}
private void FillListView()
{
try
{
ListViewImages.ItemsSource = null;
ListViewImages.Items.Clear();
ObservableCollection <ManagementPackImage> ImagesCol = new ObservableCollection <ManagementPackImage>();
ManagementPack mp = emg.GetManagementPack("SMCenter.AssetManagement.Resources", "75b45bd6835084b1", new Version());
//ManagementPackImage Im = new ManagementPackImage(mp, "ItamHardwareFolder48x48", ManagementPackAccessibility.Internal);
foreach (ManagementPackResource Res in mp.GetResources <ManagementPackResource>())
{
if (Res is Microsoft.EnterpriseManagement.Configuration.ManagementPackImage)
{
ManagementPackImage Im = (ManagementPackImage)Res;
ImagesCol.Add(Im);
//System.Drawing.Image II = System.Drawing.Image.FromStream(Im.ImageData);
}
}
this.ListViewImages.ItemsSource = ImagesCol;
}
catch (Exception exc)
{
Trace.WriteLine(DateTime.Now + " : " + "Error in FillListViewImages() " + exc.Message);
}
}
public static string SearchObjectByEnumerationCriteriaXml(ManagementPackEnumeration mpe, ManagementPackClass mpc, ManagementPackProperty mpp)
{
ManagementPack mp = mpc.GetManagementPack();
string strMPName = MakeSafeXML(mp.Name);
string strMPVersion = MakeSafeXML(mp.Version.ToString());
string strMPPublicKeyToken = MakeSafeXML(mp.KeyToken);
string strClassName = MakeSafeXML(mpc.Name);
string strPropertyName = MakeSafeXML(mpp.Name);
// This is XML that validates against the Microsoft.EnterpriseManagement.Core.Criteria schema.
string strCriteria = String.Format(@"
<Criteria xmlns=""http://Microsoft.EnterpriseManagement.Core.Criteria/"">
<Reference Id=""{0}"" Version=""{1}"" PublicKeyToken=""{2}"" Alias=""MP"" />
<Expression>
<SimpleExpression>
<ValueExpressionLeft>
<Property>$Target/Property[Type='MP!{3}']/{4}$</Property>
</ValueExpressionLeft>
<Operator>Equal</Operator>
<ValueExpressionRight>
<Value>{{{5}}}</Value>
</ValueExpressionRight>
</SimpleExpression>
</Expression>
</Criteria>
", strMPName, strMPVersion, strMPPublicKeyToken, strClassName, strPropertyName, mpe.Id.ToString());
return(strCriteria);
}
protected override void ProcessRecord()
{
// If nothing has changed, stop
if (!hasChanged)
{
ThrowTerminatingError(
new ErrorRecord(
new ArgumentException("No values have changed, please provide new values for the incident"),
"Incident",
ErrorCategory.InvalidOperation,
"NoNewValues")
);
}
try
{
systemMp = _mg.ManagementPacks.GetManagementPack(SystemManagementPack.System);
try
{
clsIncident = SMHelpers.GetManagementPackClass(ClassTypes.System_WorkItem_Incident, SMHelpers.GetManagementPack(ManagementPacks.System_WorkItem_Incident_Library, _mg), _mg);
}
catch
{
try
{
// last ditch try to get a class (this happens if a debug build is used
clsIncident = _mg.EntityTypes.GetClasses(new ManagementPackClassCriteria("Name = 'System.WorkItem.Incident'")).First();
}
catch (Exception e)
{
ThrowTerminatingError(new ErrorRecord(e, "badclass", ErrorCategory.ObjectNotFound, "System.WorkItem.Incident"));
}
}
int i = 1;
if (InputObject != null)
{
foreach (var item in this.InputObject)
{
ProgressRecord prog = new ProgressRecord(1, "Updating " + item.Object.DisplayName, String.Format("{0} of {1}", i, this.InputObject.Length.ToString()));
WriteProgress(prog);
SMHelpers.UpdateIncident(_mg, clsIncident, item, this.Impact, this.Urgency, this.Status, this.Classification, this.Source, this.SupportGroup, this.Comment, this.UserComment, this.Description, this.AttachmentPath);
i++;
}
}
else
{
WriteDebug("No input object passed");
if (this._ID != null)
{
UpdateNamedIncident(_mg, this._ID);
}
}
}
catch (Exception ex)
{
ThrowTerminatingError(new ErrorRecord(ex, "BadSet", ErrorCategory.InvalidOperation, InputObject));
}
}
//---------------------------------------------------------------------
internal MP(ManagementPack mp)
{
Debug.Assert(mp != null);
m_mp = mp;
m_classCollection = new Dictionary <Guid, MPClass>();
}
//---------------------------------------------------------------------
internal MP(ManagementPack mp)
{
Debug.Assert(mp != null);
m_mp = mp;
m_classCollection = new Dictionary<Guid, MPClass>();
}
private void buttonOK_Click(object sender, EventArgs e)
{
//since the form has multi-select disabled, the selected item is always index 0
IEnumerable<ManagementPack> ChosenMPCollection = MPList.Where(mp => mp.Name.Equals(this.MPSortableList.SelectedItems[0].Text));
ChosenMP = ChosenMPCollection.ToList()[0];
this.Close();
return;
}
public bool DeleteProjectConnector(IDataItem item)
{
try
{
//get the connector class. Later we will get the type projection so we can delete related objects.
//item = ConsoleContextHelper.Instance.GetInstance((Guid)item["$Id$"]);
//get type projection of the connector (Cireson.ProjectAutomation.ConnectorRelatesToProjects.ProjectionType) (34e516cf-644f-11b7-be02-6c886ec0573b)
item = ConsoleContextHelper.Instance.GetProjectionInstance((Guid)item["$Id$"], new Guid("34e516cf-644f-11b7-be02-6c886ec0573b"));
//add in some sort of confirmation on delete... later.
if (MessageBox.Show(
String.Format(ServiceManagerLocalization.GetStringFromManagementPack("strConfirmDelete") + " {0}", item["DisplayName"]),
ServiceManagerLocalization.GetStringFromManagementPack("strDeleteConnector"), MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
{
return(false);
}
var emg = ConsoleContext.GetConsoleEMG();
var emoConnector = emg.EntityObjects.GetObject <EnterpriseManagementObject>((Guid)item["$Id$"], ObjectQueryOptions.Default);
var iddRemove = new IncrementalDiscoveryData();
// (Cireson.ProjectAutomation.Library) (System.ProjectConfigItemRelatesToProjectConnector) (da061582-3f6c-d7b7-d17d-0a91b8a51ace)
ManagementPackRelationship mprConnectorHasProject = emg.EntityTypes.GetRelationshipClass(new Guid("da061582-3f6c-d7b7-d17d-0a91b8a51ace"));
//remove the related project CIs.
foreach (EnterpriseManagementRelationshipObject <EnterpriseManagementObject> obj in
emg.EntityObjects.GetRelationshipObjectsWhereSource <EnterpriseManagementObject>(emoConnector.Id, mprConnectorHasProject, DerivedClassTraversalDepth.None, TraversalDepth.OneLevel, ObjectQueryOptions.Default))
{
iddRemove.Remove(obj.TargetObject);
}
//remove workflow rule for the connector
try
{
//Cireson Project Server Automation Library Configuration (Cireson.ProjectAutomation.Library.Configuration) (19b2a173-bea9-9e50-0709-1470424916f2)
ManagementPack mpConnectorWorkflow = emg.ManagementPacks.GetManagementPack(new Guid("19b2a173-bea9-9e50-0709-1470424916f2"));
//Project Server Connector (Cireson.ProjectAutomation.Library) (Microsoft.SystemCenter.Connector.ProjectServer) (d581d2d6-b6cd-b558-7ac7-db233a7c82ec)
ManagementPackClass mpcConnector = emg.EntityTypes.GetClass(new Guid("d581d2d6-b6cd-b558-7ac7-db233a7c82ec"));
string sConnectorRuleId = string.Format("{0}.{1}", "Cireson.ProjectServer.Automation", new Guid(emoConnector[mpcConnector, "Id"].Value.ToString()).ToString("N"));
ManagementPackRule mprConnector = mpConnectorWorkflow.GetRule(sConnectorRuleId);
mprConnector.Status = ManagementPackElementStatus.PendingDelete;
mpConnectorWorkflow.AcceptChanges();
}
catch
{ }
iddRemove.Remove(emoConnector);
iddRemove.Commit(emg);
return(true);
}
catch (Exception ex)
{
ConsoleContextHelper.Instance.ShowErrorDialog(ex, string.Empty, ConsoleJobExceptionSeverity.Error);
return(false);
}
}
private void GetSharedUserData()
{
this.name = base.SharedUserData["NameAndDescriptionPage.Name"] as string;
this.description = base.SharedUserData["NameAndDescriptionPage.Description"] as string;
this.outputManagementPack = base.SharedUserData["NameAndDescriptionPage.ManagementPack"] as ManagementPack;
this.asbNamespaceName = base.SharedUserData["ASBNamespaceDetails.ASBNamespaceName"] as string;
this.runAsName = SharedUserData["ASBNamespaceDetails.RunAsName"] as string;
this.proxyAgent = SharedUserData["ProxyAgent.ProxyAgentComputerPrincipalName"] as string;
}
private static void getServiceManagerBrandingProperties(string managementServerName, string netbiosComputerName, ref string attestationFrequency,
ref string ChargebackGroup, ref string Description, ref string NotificationGroup,
ref string ServerOwner1, ref string ServiceLevel, ref string VirtualCenter)
{
//Connect to Management Group
EnterpriseManagementGroup mg = new EnterpriseManagementGroup(managementServerName);
ManagementPack mp = mg.GetManagementPack("GMI.SM.BaseClasses.Extension", "c17ba471fb087385", new Version());
ManagementPackClass requestClass = mp.GetClass("ClassExtension_c270fe5b_740f_4a9c_828c_b35e8fe739a9");
EnterpriseManagementObjectCriteria criteria = new EnterpriseManagementObjectCriteria(String.Format("NetbiosComputerName='{0}'", netbiosComputerName), requestClass);
IObjectReader <EnterpriseManagementObject> reader = mg.EntityObjects.GetObjectReader <EnterpriseManagementObject>(criteria, ObjectQueryOptions.Default);
foreach (EnterpriseManagementObject item in reader)
{
foreach (ManagementPackProperty mpp in item.GetProperties())
{
switch (mpp.Name)
{
case "AttestationFrequency":
try { attestationFrequency = item[mpp].Value.ToString(); }
catch { ChargebackGroup = String.Empty; }
break;
case "ChargebackGroup":
try { ChargebackGroup = item[mpp].Value.ToString(); }
catch { ChargebackGroup = String.Empty; }
break;
case "Description":
try { Description = item[mpp].Value.ToString(); }
catch { Description = String.Empty; }
break;
case "NotificationGroup":
try { NotificationGroup = item[mpp].Value.ToString(); }
catch { ChargebackGroup = String.Empty; }
break;
case "ServerOwner1":
try { ServerOwner1 = item[mpp].Value.ToString(); }
catch { ChargebackGroup = String.Empty; }
break;
case "ServiceLevel":
try { ServiceLevel = item[mpp].Value.ToString(); }
catch { ChargebackGroup = String.Empty; }
break;
case "VirtualCenter":
try { VirtualCenter = item[mpp].Value.ToString(); }
catch { ChargebackGroup = String.Empty; }
break;
}
}
}
}
private void buttonOK_Click(object sender, EventArgs e)
{
//since the form has multi-select disabled, the selected item is always index 0
IEnumerable <ManagementPack> ChosenMPCollection = MPList.Where(mp => mp.Name.Equals(this.MPSortableList.SelectedItems[0].Text));
ChosenMP = ChosenMPCollection.ToList()[0];
this.Close();
return;
}
private void GetSharedUserData()
{
this.name = base.SharedUserData["NameAndDescriptionPage.Name"] as string;
this.description = base.SharedUserData["NameAndDescriptionPage.Description"] as string;
this.outputManagementPack = base.SharedUserData["NameAndDescriptionPage.ManagementPack"] as ManagementPack;
this.sbwsNamespaceName = base.SharedUserData["SBWSNamespaceDetails.SBWSNamespaceName"] as string;
this.runAsName = SharedUserData["SBWSNamespaceDetails.RunAsName"] as string;
this.hostName = SharedUserData["SBWSNamespaceDetails.SBWSHostName"] as string;
}
protected override void BeginProcessing()
{
base.BeginProcessing();
// get the BaseEnums, these are used later!
impactBase = SMHelpers.GetEnum("System.WorkItem.TroubleTicket.ImpactEnum", _mg);
urgencyBase = SMHelpers.GetEnum("System.WorkItem.TroubleTicket.UrgencyEnum", _mg);
statusBase = SMHelpers.GetEnum("IncidentStatusEnum", _mg);
classificationBase = SMHelpers.GetEnum("IncidentClassificationEnum", _mg);
systemMp = _mg.ManagementPacks.GetManagementPack(SystemManagementPack.System);
incidentMp = _mg.ManagementPacks.GetManagementPacks(new ManagementPackCriteria("Name = 'System.WorkItem.Incident.Library'")).First();
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigurationPackConnector"/> class.
/// Connects to the provided management server or URI
/// </summary>
public ConfigurationPackConnector()
{
Log.WriteTrace(
EventType.UIActivity,
"Connecting to configuration override Management Pack");
try
{
ManagementGroup managementGroupConnection = ManagementGroupConnector.CurrentManagementGroup;
ManagementPackCriteria packCriteria = new ManagementPackCriteria("Name = 'Community.ManagementPackCatalog.Configuration'");
var packResults = managementGroupConnection.ManagementPacks.GetManagementPacks(packCriteria);
if (packResults.Count == 1)
{
// Good news, we should only see one
configurationOverridePack = packResults[0];
}
else if (packResults.Count == 0)
{
// install the shell unsealed pack
try
{
DialogResult installPack = System.Windows.Forms.MessageBox.Show(
"A small unsealed MP is required to configure the alerting, can we create it now?"
+ Environment.NewLine + "Community.ManagementPackCatalog.Configuration will be created for alert configuration overrides."
, "Create Override Pack?"
, System.Windows.Forms.MessageBoxButtons.YesNo
, System.Windows.Forms.MessageBoxIcon.Information);
if (installPack == DialogResult.Yes)
{
InstallConfigurationPack();
}
else
{
throw new Exception("The Settings pane cannot be used without the unsealed Configuration management pack.");
}
}
catch (Exception ex)
{
Log.WriteError(
EventType.UIActivity,
"Unable to install management pack.",
ex.Message);
}
}
}
catch (Exception ex)
{
Log.WriteError(
EventType.ExternalDependency,
"Unable to connect to Management Group and Get Override Pack",
ex.Message);
}
}
public static ManagementPack GetManagementPackByName(string strManagementPackName, EnterpriseManagementGroup emg)
{
ManagementPack mpToReturn = null;
ManagementPackCriteria mpc = new ManagementPackCriteria(String.Format("Name = '{0}'", strManagementPackName));
foreach (ManagementPack mp in emg.ManagementPacks.GetManagementPacks(mpc))
{
mpToReturn = mp;
}
return(mpToReturn);
}
//---------------------------------------------------------------------
internal OverrideMover(
ManagementPack sourceMp,
ManagementPack targetMp,
ManagementPackOverride mpOverride,
MPWorkflow mpWorkflow
)
{
m_mpOverride = mpOverride;
m_sourceMp = sourceMp;
m_targetMp = targetMp;
m_mpWorkflow = mpWorkflow;
}
//---------------------------------------------------------------------
internal OverrideMover(
ManagementPack sourceMp,
ManagementPack targetMp,
ManagementPackOverride mpOverride,
MPWorkflow mpWorkflow
)
{
m_mpOverride = mpOverride;
m_sourceMp = sourceMp;
m_targetMp = targetMp;
m_mpWorkflow = mpWorkflow;
}
private void UpdateConnectorInstance()
{
//Get the server name to connect to and connect
String strServerName = Registry.GetValue("HKEY_CURRENT_USER\\Software\\Microsoft\\System Center\\2010\\Service Manager\\Console\\User Settings", "SDKServiceMachine", "localhost").ToString();
EnterpriseManagementGroup emg = new EnterpriseManagementGroup(strServerName);
//Get the Connectors MP and CSV Connector Class
ManagementPack mpConnectors = emg.GetManagementPack("Microsoft.Demo.Connectors", null, new Version("1.0.0.0"));
ManagementPackClass classCSVConnector = mpConnectors.GetClass("Microsoft.Demo.Connectors.CSVConnector");
//Get the Connector object using the object ID
EnterpriseManagementObject emoCSVConnector = emg.EntityObjects.GetObject <EnterpriseManagementObject>(this.EnterpriseManagementObjectID, ObjectQueryOptions.Default);
//Set the property values to the new values
emoCSVConnector[classCSVConnector, "DisplayName"].Value = this.DisplayName;
emoCSVConnector[classCSVConnector, "DataFilePath"].Value = this.DataFilePath;
emoCSVConnector[classCSVConnector, "DataFilePath"].Value = this.DataFilePath;
emoCSVConnector[classCSVConnector, "MappingFilePath"].Value = this.MappingFilePath;
emoCSVConnector[classCSVConnector, "NumberMinutes"].Value = this.NumberMinutes;
//Update Connector instance
emoCSVConnector.Commit();
//Get the rule using the Connector ID and then update the data source and write action module configuration
ManagementPackRule ruleConnector = mpConnectors.GetRule(this.ConnectorID);
ruleConnector.DataSourceCollection[0].Configuration =
"<Scheduler>" +
"<SimpleReccuringSchedule>" +
"<Interval Unit=\"Minutes\">" + this.NumberMinutes + "</Interval>" +
"</SimpleReccuringSchedule>" +
"<ExcludeDates />" +
"</Scheduler>";
ruleConnector.WriteActionCollection[0].Configuration =
"<Subscription>" +
"<WindowsWorkflowConfiguration>" +
"<AssemblyName>CSVConnectorWorkflow</AssemblyName>" +
"<WorkflowTypeName>WorkflowAuthoring.CSVConnectorWorkflow</WorkflowTypeName>" +
"<WorkflowParameters>" +
"<WorkflowParameter Name=\"DataFilePath\" Type=\"string\">" + this.DataFilePath + "</WorkflowParameter>" +
"<WorkflowParameter Name=\"FormatFilePath\" Type=\"string\">" + this.MappingFilePath + "</WorkflowParameter>" +
"</WorkflowParameters>" +
"<RetryExceptions />" +
"<RetryDelaySeconds>60</RetryDelaySeconds>" +
"<MaximumRunningTimeSeconds>300</MaximumRunningTimeSeconds>" +
"</WindowsWorkflowConfiguration>" +
"</Subscription>";
ruleConnector.Status = ManagementPackElementStatus.PendingUpdate;
mpConnectors.AcceptChanges();
}
//---------------------------------------------------------------------
internal static string GetBestManagementPackName(
ManagementPack managementPack
)
{
if (managementPack.DisplayName != null && managementPack.DisplayName.Length > 0)
{
return(managementPack.DisplayName);
}
else
{
return(managementPack.Name);
}
}
//---------------------------------------------------------------------
internal static string GetBestManagementPackName(
ManagementPack managementPack
)
{
if (managementPack.DisplayName != null && managementPack.DisplayName.Length > 0)
{
return (managementPack.DisplayName);
}
else
{
return (managementPack.Name);
}
}
public static EnterpriseManagementObject GetUserFromEmailAddress(string strEmailAddress, EnterpriseManagementGroup emg)
{
strEmailAddress = MakeSafeXML(strEmailAddress);
ManagementPack mpSystemNotificationsLibrary = GetManagementPackByName("System.Notifications.Library", emg);
ManagementPack mpSystemSupportingItemLibrary = GetManagementPackByName("System.SupportingItem.Library", emg);
if (mpSystemNotificationsLibrary != null &&
mpSystemSupportingItemLibrary != null)
{
EnterpriseManagementObject emoSCSMUser = null;
//Criteria to get a user provided the email address
string strCriteria = String.Format(@"
<Criteria xmlns=""http://Microsoft.EnterpriseManagement.Core.Criteria/"">
<Reference Id=""{0}"" Version=""{1}"" PublicKeyToken=""{2}"" Alias=""NotificationLibrary"" />
<Reference Id=""{3}"" Version=""{4}"" PublicKeyToken=""{5}"" Alias=""SupportingItemLibrary"" />
<Expression>
<SimpleExpression>
<ValueExpressionLeft>
<Property>$Target/Path[Relationship='SupportingItemLibrary!System.UserHasPreference' TypeConstraint='NotificationLibrary!System.Notification.Endpoint']/Property[Type='NotificationLibrary!System.Notification.Endpoint']/TargetAddress$</Property>
</ValueExpressionLeft>
<Operator>Equal</Operator>
<ValueExpressionRight>
<Value>{6}</Value>
</ValueExpressionRight>
</SimpleExpression>
</Expression>
</Criteria>",
mpSystemNotificationsLibrary.Name,
mpSystemNotificationsLibrary.Version.ToString(),
mpSystemNotificationsLibrary.KeyToken,
mpSystemSupportingItemLibrary.Name,
mpSystemSupportingItemLibrary.Version.ToString(),
mpSystemSupportingItemLibrary.KeyToken,
strEmailAddress);
ManagementPackTypeProjection mptpUserPreferences = GetTypeProjectionByName("System.User.Preferences.Projection", emg);
ObjectProjectionCriteria opcFindNotificationEndPointByEmailAddress = new ObjectProjectionCriteria(strCriteria, mptpUserPreferences, emg);
IObjectProjectionReader <EnterpriseManagementObject> readerNotificationEndpoints = emg.EntityObjects.GetObjectProjectionReader <EnterpriseManagementObject>(opcFindNotificationEndPointByEmailAddress, ObjectQueryOptions.Default);
foreach (EnterpriseManagementObjectProjection emopNotificationEndpointItem in readerNotificationEndpoints)
{
emoSCSMUser = emopNotificationEndpointItem.Object;
}
return(emoSCSMUser);
}
else
{
return(null);
}
}
private void TestGettingIncidentsByEnumCriteria()
{
EnterpriseManagementGroup emg = new EnterpriseManagementGroup(txtServerName.Text);
ManagementPack mpIncidentLibrary = Helper.GetManagementPackByName("System.WorkItem.Incident.Library", emg);
ManagementPackClass mpcIncident = Helper.GetClassByName("System.WorkItem.Incident", emg);
ManagementPackProperty mppClassification = Helper.GetManagementPackClassPropertyByName("System.WorkItem.Incident", "Classification", emg);
ManagementPackTypeProjection mptpIncident = Helper.GetTypeProjectionByName("System.WorkItem.Incident.View.ProjectionType", emg);
ManagementPackEnumeration mpeClassificationEnterpriseApp = Helper.GetEnumerationByName("IncidentClassificationEnum.EnterpriseApplications", emg);
string strCriteria = Helper.SearchObjectByEnumerationCriteriaXml(mpeClassificationEnterpriseApp, mpcIncident, mppClassification);
IObjectProjectionReader <EnterpriseManagementObject> reader = Helper.GetBufferedObjectProjectionReader(strCriteria, 40, mptpIncident, emg);
MessageBox.Show(reader.Count.ToString());
}
public static void AddManagementPackReference(string strAlias, string strMPName, ref ManagementPack mp, EnterpriseManagementGroup emg)
{
ManagementPack mpReference = GetManagementPackByName(strMPName, emg);
ManagementPackReference mpr = new ManagementPackReference(mpReference);
foreach (KeyValuePair <string, ManagementPackReference> mprExisting in mp.References)
{
if (mprExisting.Value.Name == strMPName)
{
return;
}
}
mp.References.Add(strAlias, mpr);
return;
}
public static string GetStringFromManagementPack(string resource)
{
try
{
if (projectMP == null)
{
EnterpriseManagementGroup emg = ConsoleContext.GetConsoleEMG();
projectMP = emg.ManagementPacks.GetManagementPack(new Guid("171d60e8-a0df-e4b2-f032-a5af5c8ebe39"));
}
return(projectMP.GetStringResource(resource).DisplayName);
}
catch
{
return("Localization Error.");
}
}
public ManagementPackClass GetManagementPackClass(string Name, ManagementPack mp)
{
return _emg.EntityTypes.GetClass(Name, mp);
}
private async Task RenewServiceCredential(GraphClient cl, ManagementPack configMp, AdApplication app, TimeSpan credValidity)
{
if (app == null)
throw new ArgumentNullException(nameof(app));
if (app.PasswordCredentials != null)
{
var passCred = app.PasswordCredentials.FirstOrDefault(x => x.CustomKeyIdentifier == Convert.ToBase64String(_emg.Id.ToByteArray()));
if (passCred != null)
app.PasswordCredentials.Remove(passCred);
await cl.UpdateApplicationAsync(app);
}
var pass = RandomString();
var securePass = new System.Security.SecureString();
foreach (char c in pass)
securePass.AppendChar(c);
var endDate = DateTime.UtcNow + credValidity;
app.PasswordCredentials.Add(new PasswordCredential()
{
EndDate = endDate,
StartDate = DateTime.UtcNow,
KeyId = Guid.NewGuid(),
Value = pass,
CustomKeyIdentifier = Convert.ToBase64String(_emg.Id.ToByteArray())
});
await cl.UpdateApplicationAsync(app);
bool isNew = false;
var secData = (BasicCredentialSecureData)_emg.Security.GetSecureData(new SecureDataCriteria($"Name = '{Parameters.SECURE_REFERENCE_NAME}'")).FirstOrDefault();
if (secData == null)
{
secData = new BasicCredentialSecureData();
isNew = true;
}
secData.UserName = app.AppId.ToString();
secData.Data = securePass;
secData.Name = Parameters.SECURE_REFERENCE_NAME;
if (isNew)
_emg.Security.InsertSecureData(secData);
secData.Update();
var secRefOverride = (ManagementPackSecureReferenceOverride)_emg.Overrides.GetOverrides(new ManagementPackOverrideCriteria($"Name = '{Parameters.SECURE_REFERENCE_OVERRIDE_NAME}'")).FirstOrDefault();
if (secRefOverride == null)
secRefOverride = new ManagementPackSecureReferenceOverride(configMp, Parameters.SECURE_REFERENCE_OVERRIDE_NAME);
secRefOverride.DisplayName = Parameters.SECURE_REFERENCE_OVERRIDE_NAME;
secRefOverride.Context = EntityClass;
secRefOverride.SecureReference = ConnectorSecureReference;
secRefOverride.Value = BitConverter.ToString(secData.SecureStorageId, 0, secData.SecureStorageId.Length).Replace("-", "");
secRefOverride.GetManagementPack().AcceptChanges();
Settings.CredentialExpirationDate = endDate;
}
private async Task RemoveServiceCredential(GraphClient cl, ManagementPack configMp)
{
var secRefOverride = (ManagementPackSecureReferenceOverride)_emg.Overrides.GetOverrides(new ManagementPackOverrideCriteria($"Name = '{Parameters.SECURE_REFERENCE_OVERRIDE_NAME}'")).FirstOrDefault();
if (secRefOverride != null)
{
secRefOverride.Status = ManagementPackElementStatus.PendingDelete;
secRefOverride.GetManagementPack().AcceptChanges();
}
var secData = (BasicCredentialSecureData)_emg.Security.GetSecureData(new SecureDataCriteria($"Name = '{Parameters.SECURE_REFERENCE_NAME}'")).FirstOrDefault();
if (secData != null)
_emg.Security.DeleteSecureData(secData);
var app = await cl.GetApplicationAsync();
if (app != null && app.PasswordCredentials != null)
{
var passCred = app.PasswordCredentials.FirstOrDefault(x => x.CustomKeyIdentifier == Convert.ToBase64String(_emg.Id.ToByteArray()));
if (passCred != null)
{
app.PasswordCredentials.Remove(passCred);
await cl.UpdateApplicationAsync(app);
}
}
}
/*
public void DisableWorkflows()
{
var mp = AssureConfigManagementPack();
DisableWorkflow(mp, Parameters.WORKFLOW_NAME_MONITORJOBS);
DisableWorkflow(mp, Parameters.WORKFLOW_NAME_STARTRUNBOOK);
mp.AcceptChanges();
}
public void DisableWorkflow(ManagementPack mp, string ruleName)
{
var overrideName = $"{ruleName}.Override";
var ruleOverride = (ManagementPackRulePropertyOverride)_emg.Overrides.GetOverrides(new ManagementPackOverrideCriteria($"Name = '{overrideName}'")).FirstOrDefault();
if (ruleOverride != null)
ruleOverride.Status = ManagementPackElementStatus.PendingDelete;
}
public void EnableWorkflows()
{
var mp = AssureConfigManagementPack();
EnableWorkflow(mp, Parameters.WORKFLOW_NAME_MONITORJOBS);
EnableWorkflow(mp, Parameters.WORKFLOW_NAME_STARTRUNBOOK);
mp.AcceptChanges();
}
public void EnableWorkflow(ManagementPack mp, string ruleName)
{
var rule = _emg.Monitoring.GetRules(new ManagementPackRuleCriteria($"Name = '{ruleName}'")).FirstOrDefault();
var overrideName = $"{ruleName}.Override";
var ruleOverride = (ManagementPackRulePropertyOverride)_emg.Overrides.GetOverrides(new ManagementPackOverrideCriteria($"Name = '{overrideName}'")).FirstOrDefault();
if (ruleOverride == null)
ruleOverride = new ManagementPackRulePropertyOverride(mp, overrideName);
ruleOverride.Rule = rule;
ruleOverride.Property = ManagementPackWorkflowProperty.Enabled;
ruleOverride.Value = "true";
ruleOverride.Context = EntityClass;
ruleOverride.Enforced = true;
ruleOverride.DisplayName = $"Enable {ruleName}";
}
*/
public ManagementPack AssureConfigManagementPack()
{
var mp = _emg.ManagementPacks.GetManagementPacks(new ManagementPackCriteria($"Name = '{Parameters.CONFIGMP_NAME}'")).FirstOrDefault();
if (mp == null)
{
mp = new ManagementPack(Parameters.CONFIGMP_NAME, Parameters.CONFIGMP_NAME, Parameters.CONFIGMP_VERSION, _emg);
mp.DisplayName = Parameters.CONFIGMP_DISPLAYNAME;
mp.AcceptChanges();
_emg.ManagementPacks.ImportManagementPack(mp);
}
return mp;
}
private static ManagementPack LoadManagementPack(string[] args)
{
ManagementPackFileStore store = Utilities.GetManagementPackStoreFromPath(args[0]);
ManagementPack mp;
if (System.IO.Path.GetExtension(args[0]).Equals(".mpb"))
{
ManagementPackBundleReader reader = ManagementPackBundleFactory.CreateBundleReader();
ManagementPackBundle bundle = reader.Read(args[0], store);
// 1 at the time is ok
if (bundle.ManagementPacks.Count == 1)
{
mp = bundle.ManagementPacks[0];
return mp;
}
else
{
// too many MPs contained in this MPB! - can onlhy open one at the time!
// do something sensible here
throw new ApplicationException("This MPB contains multiple MPs. " +
"In an upcoming version a dialog will open, asking you to choose which one you want to see. " +
"For now, we just are going to crash.");
}
}
else // we are dealing with an MP or XML - the old stuff works as it did for 2007
{
mp = new ManagementPack(args[0], store);
return mp;
}
}
//---------------------------------------------------------------------
internal ReportGenerator(DataSet dataSet,ManagementPack mp)
{
m_dataset = dataSet;
m_mp = mp;
}
//---------------------------------------------------------------------
private void loadManagementPackToolStripMenuItem_Click(object sender, EventArgs e)
{
m_openFileDialog = new OpenFileDialog();
m_openFileDialog.AddExtension = true;
m_openFileDialog.CheckPathExists = true;
m_openFileDialog.DefaultExt = "mp";
m_openFileDialog.Filter = "Sealed MP files (*.mp)|*.mp|Sealed MP bundles (*.mpb)|*.mpb|Unsealed MP files (*.xml)|*.xml";
m_openFileDialog.InitialDirectory = (string)Application.UserAppDataRegistry.GetValue("MPFolder", (object)"C:\\");
if (m_openFileDialog.ShowDialog() != DialogResult.OK)
{
return;
}
Cursor = Cursors.WaitCursor;
ManagementPackFileStore store = Utilities.GetManagementPackStoreFromPath(m_openFileDialog.FileName);
if (System.IO.Path.GetExtension(m_openFileDialog.FileName).Equals(".mpb", StringComparison.InvariantCultureIgnoreCase))
{
ManagementPackBundleReader reader = ManagementPackBundleFactory.CreateBundleReader();
m_bundle = reader.Read(m_openFileDialog.FileName, store);
// 1 at the time is ok
if (m_bundle.ManagementPacks.Count == 1)
{
m_managementPack = m_bundle.ManagementPacks[0];
}
else
{
// multiple MPs contained in this MPB! - can only open one at the time! Need to ask the user which one.
MultipleMPSelectionForm MPListForm = new MultipleMPSelectionForm(m_bundle.ManagementPacks);
MPListForm.ShowDialog();
//selected in the form
m_managementPack = MPListForm.ChosenMP;
}
}
else // we are dealing with an MP or XML - the old stuff works as it did for 2007
{
m_managementPack = new ManagementPack(m_openFileDialog.FileName, store);
}
ClearViews();
PopulateObjectTypeTree();
Application.UserAppDataRegistry.SetValue("MPFolder",
Path.GetDirectoryName(m_openFileDialog.FileName));
if (m_managementPack.KeyToken != null)
{
Text = string.Format("Management Pack Viewer 2012 - {0} {1} {2}",
Utilities.GetBestManagementPackName(m_managementPack),
m_managementPack.Version.ToString(),
m_managementPack.KeyToken.ToString());
}
else
{
//TODO - Unsealed don't have keytoken!
Text = string.Format("Management Pack Viewer 2012 - {0} {1} Unsealed",
Utilities.GetBestManagementPackName(m_managementPack),
m_managementPack.Version.ToString());
}
//loading dataset is memory expensive and can take time... so moved to a worker thread
this.m_progressDialog = new ProgressDialog();
this.m_progressDialog.Show(this);
this.backgroundWorker.RunWorkerAsync();
Cursor = Cursors.Default;
// now that an MP is loaded, enable the menus
saveToHTMLToolStripMenuItem.Enabled = true;
saveToExcelToolStripMenuItem.Enabled = true;
//this might make sense or not, if we have loaded XML...
if (System.IO.Path.GetExtension(m_openFileDialog.FileName).Equals(".mpb", StringComparison.InvariantCultureIgnoreCase) ||
System.IO.Path.GetExtension(m_openFileDialog.FileName).Equals(".mp", StringComparison.InvariantCultureIgnoreCase))
{
unsealManagementPackToolStripMenuItem.Enabled = true;
}
}
private void fileToolStripMenuItem1_Click(object sender, EventArgs e)
{
m_managementPack.Clear();
m_openFileDialog = new OpenFileDialog();
MPList = new List<ManagementPack>();
ResourceList = new Dictionary<string, Stream>();
m_openFileDialog.AddExtension = true;
m_openFileDialog.CheckPathExists = true;
m_openFileDialog.Multiselect = true;
m_openFileDialog.DefaultExt = "mp";
m_openFileDialog.Filter = "MultiSelect (*.mp;*.xml;*.mpb)|*.xml;*.mp;*.mpb|Sealed MP files (*.mp)|*.mp|Sealed MP bundles (*.mpb)|*.mpb|Unsealed MP files (*.xml)|*.xml";
m_openFileDialog.InitialDirectory = (string)Application.UserAppDataRegistry.GetValue("MPFolder", (object)"C:\\");
if (m_openFileDialog.ShowDialog() != DialogResult.OK)
{
return;
}
Cursor = Cursors.WaitCursor;
ManagementPackFileStore store = Utilities.GetManagementPackStoreFromPath(m_openFileDialog.FileName);
foreach (string FileName in m_openFileDialog.FileNames)
{
if (System.IO.Path.GetExtension(FileName).Equals(".mpb", StringComparison.InvariantCultureIgnoreCase))
{
ManagementPackBundleReader reader = ManagementPackBundleFactory.CreateBundleReader();
try {
m_bundle = reader.Read(FileName, store);
foreach (ManagementPack MP in m_bundle.ManagementPacks)
{
m_managementPack.Add(MP.Name, MP);
IDictionary<string, Stream> streams = m_bundle.GetStreams(MP);
foreach (ManagementPackResource resource in MP.GetResources<ManagementPackResource>())
{
if (!resource.HasNullStream && streams[resource.Name] != null)
{
ResourceList.Add(resource.FileName, streams[resource.Name]);
}
}
}
} catch {}
}
else {
try
{
ManagementPack MP = new ManagementPack(FileName, store);
m_managementPack.Add(MP.Name, MP);
}
catch { }
}
}
Mode = MPMode.File;
MPPath = Path.GetDirectoryName(m_openFileDialog.FileNames[0]);
ProcessManagementPacks();
}
public MPViewer(string path)
{
Init();
ManagementPack MP;
try {
MP = new ManagementPack(path);
m_managementPack.Add(MP.Name, MP);
ProcessManagementPacks();
saveToExcelToolStripMenuItem.Enabled = true;
unsealManagementPackToolStripMenuItem.Enabled = true;
saveToHTMLToolStripMenuItem.Enabled = true;
} catch(Exception ex) { MessageBox.Show("Not a valid MP: " + path + "\r\n" + ex.Message); }
}
private void reloadToolStripMenuItem_Click(object sender, EventArgs e)
{
if(Mode == MPMode.ManagementGroup){
if (emg != null && emg.IsConnected)
{
foreach (ManagementPack MP in m_managementPack.Values.ToList<ManagementPack>())
{
ManagementPack item = null;
try
{
item = emg.GetManagementPack(MP.Id);
}
catch { }
if (item != null)
{
m_managementPack[MP.Name] = item;
}
else
{
m_managementPack.Remove(MP.Name);
}
}
}
else { MessageBox.Show("Management Group disconnected, reload not possible"); return; }
}
if(Mode == MPMode.File){
foreach(ManagementPack MP in m_managementPack.Values.ToList<ManagementPack>()){
ManagementPack item = null;
string ext = "";
if(MP.Sealed == true){
ext = ".mp";
} else {
ext = ".xml";
}
try{
item = new ManagementPack(MPPath + '\\' + MP.Name + ext);
}
catch{}
if(item != null){
m_managementPack[MP.Name] = item;
} else {
m_managementPack.Remove(MP.Name);
}
}
ProcessManagementPacks();
}
}
internal static string GetManagementPackSealedFlag(
ManagementPack managementPack
)
{
return managementPack.Sealed.ToString();
}
