public void BrandNewComponent()
{
// Create a branch new component and submit the transaction.
// This should trigger the add-on.
// Next, go and check that the Component has a Path, and that that Path exists on disk.
var project = fixture.GetProject();
project.EnableAutoAddOns(true);
project.PerformInTransaction(delegate
{
CyPhy.RootFolder rf = ISIS.GME.Common.Utils.CreateObject <CyPhyClasses.RootFolder>(project.RootFolder as MgaObject);
CyPhy.Components cf = rf.Children.ComponentsCollection.First();
CyPhy.Component comp = CyPhyClasses.Component.Create(cf);
comp.Name = "BrandNewComponent";
});
project.PerformInTransaction(delegate
{
var matchingComponents = project.GetComponentsByName("BrandNewComponent");
Assert.Equal(1, matchingComponents.Count());
var comp_Retrieved = matchingComponents.First();
Assert.True(!String.IsNullOrWhiteSpace(comp_Retrieved.Attributes.AVMID), "Retrieved component is missing AVMID.");
Assert.True(!String.IsNullOrWhiteSpace(comp_Retrieved.Attributes.Path), "Retrieved component is missing Path.");
Assert.True(Directory.Exists(comp_Retrieved.GetDirectoryPath(ComponentLibraryManager.PathConvention.ABSOLUTE)), "Component path doesn't exist.");
});
project.Save();
}
private avm.Component FindAndConvert(string compName, string compFolName)
{
avm.Component avmComp = null;
proj.PerformInTransaction(delegate
{
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder(proj);
CyPhy.Components cf = rf.Children.ComponentsCollection.First(f => f.Name == compFolName);
CyPhy.Component comp = cf.Children.ComponentCollection.First(c => c.Name == compName);
avmComp = CyPhy2ComponentModel.Convert.CyPhyML2AVMComponent(comp);
});
string outPath = Path.Combine(testPath, "output");
if (!Directory.Exists(outPath))
{
Directory.CreateDirectory(outPath);
}
CyPhyComponentExporter.CyPhyComponentExporterInterpreter.SerializeAvmComponent(avmComp, Path.Combine(outPath,
String.Format("{0}-{1}.exported.acm",
compFolName,
compName)));
return(avmComp);
}
public void Import_NewStyle_Dist()
{
string testNote = "STATEMENT C -- test note";
proj.PerformInTransaction(delegate
{
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder(proj);
CyPhy.Components cf = rf.Children.ComponentsCollection.First(f => f.Name == "Components");
avm.Component avmComp = new avm.Component()
{
Name = "Imported_NewStyle_Dist"
};
avmComp.DistributionRestriction.Add(new avm.DoDDistributionStatement()
{
Type = avm.DoDDistributionStatementEnum.StatementC,
Notes = testNote
});
var cyphyComp = CyPhy2ComponentModel.Convert.AVMComponent2CyPhyML(cf, avmComp);
Assert.False(cyphyComp.Children.ITARCollection.Any());
var distCollection = cyphyComp.Children.DoDDistributionStatementCollection;
Assert.True(distCollection.Count() == 1);
Assert.True(distCollection.First().Attributes.DoDDistributionStatementEnum
== CyPhyClasses.DoDDistributionStatement.AttributesClass.DoDDistributionStatementEnum_enum.StatementC);
Assert.Equal(testNote, distCollection.First().Attributes.Notes);
});
}
private CyPhy.ComponentAssembly CreateComponentAssemblyRoot(avm.Design ad_import)
{
CyPhy.ComponentAssemblies cyphy_cas;
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder((MgaProject)project);
cyphy_cas = rf.Children.ComponentAssembliesCollection.Where(d => d.Name == typeof(CyPhyClasses.ComponentAssemblies).Name).FirstOrDefault();
if (cyphy_cas == null)
{
cyphy_cas = CyPhyClasses.ComponentAssemblies.Create(rf);
cyphy_cas.Name = typeof(CyPhyClasses.ComponentAssemblies).Name;
}
CyPhy.ComponentAssembly cyphy_container = CyPhyClasses.ComponentAssembly.Create(cyphy_cas);
// container.Name = ad_import.Name; RootContainer has a name too
// TODO: check ad_import.SchemaVersion
int designID;
if (int.TryParse(ad_import.DesignID, out designID))
{
cyphy_container.Attributes.ID = designID;
}
if (string.IsNullOrEmpty(ad_import.RootContainer.Description) == false)
{
cyphy_container.Attributes.Description = ad_import.RootContainer.Description;
}
return(cyphy_container);
}
public void TestAddCustomIconTool()
{
string TestName = System.Reflection.MethodBase.GetCurrentMethod().Name;
string path_Test = Path.Combine(testcreatepath, TestName);
string path_Mga = Path.Combine(path_Test, TestName + ".mga");
// delete any previous test results
if (Directory.Exists(path_Test))
{
Directory.Delete(path_Test, true);
}
// create a new blank project
MgaProject proj = new MgaProject();
proj.Create("MGA=" + path_Mga, "CyPhyML");
// these are the actual steps of the test
proj.PerformInTransaction(delegate
{
// create the environment for the Component authoring class
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder(proj);
CyPhy.Components components = CyPhyClasses.Components.Create(rf);
CyPhy.Component testcomp = CyPhyClasses.Component.Create(components);
// new instance of the class to test
CyPhyComponentAuthoring.Modules.CustomIconAdd CATModule = new CyPhyComponentAuthoring.Modules.CustomIconAdd();
//// these class variables need to be set to avoid NULL references
CATModule.SetCurrentDesignElement(testcomp);
CATModule.CurrentObj = testcomp.Impl as MgaFCO;
// call the primary function directly
CATModule.AddCustomIcon(testiconpath);
// verify results
// 1. insure the icon file was copied to the back-end folder correctly
string iconAbsolutePath = Path.Combine(testcomp.GetDirectoryPath(ComponentLibraryManager.PathConvention.ABSOLUTE), "Icon.png");
Assert.True(File.Exists(iconAbsolutePath),
String.Format("Could not find the source file for the created resource, got {0}", iconAbsolutePath));
// 2. insure the resource path was created correctly
var iconResource = testcomp.Children.ResourceCollection.Where(p => p.Name == "Icon.png").First();
Assert.True(iconResource.Attributes.Path == "Icon.png",
String.Format("{0} Resource should have had value {1}; instead found {2}", iconResource.Name, "Icon.png", iconResource.Attributes.Path)
);
// 3. Verify the registry entry exists
string expected_registry_entry = Path.Combine(testcomp.GetDirectoryPath(ComponentLibraryManager.PathConvention.REL_TO_PROJ_ROOT), "Icon.png");
string registry_entry = (testcomp.Impl as GME.MGA.IMgaFCO).get_RegistryValue("icon");
Assert.True(registry_entry.Equals(expected_registry_entry),
String.Format("Registry should have had value {0}; instead found {1}", expected_registry_entry, registry_entry)
);
});
proj.Save();
proj.Close();
Directory.Delete(testcreatepath, true);
}
private void getCyPhyMLUnits(CyPhyML.RootFolder rootFolder)
{
foreach (CyPhyML.TypeSpecifications typeSpecifications in rootFolder.Children.TypeSpecificationsCollection)
{
foreach (CyPhyML.Units units in typeSpecifications.Children.UnitsCollection)
{
_cyPhyMLUnitsFolders.Add(units);
}
}
}
private CyPhy.Component ExportThenImport(CyPhyML.Component comp, out CyPhy.Components importedcomponents, String testName)
{
// export the component
avm.Component exportee = CyPhyML2AVM.AVMComponentBuilder.CyPhyML2AVM(comp);
CyPhyComponentExporter.CyPhyComponentExporterInterpreter.SerializeAvmComponent(exportee, Path.Combine(testPath, testName + ".acm"));
// import the component back in
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder(fixture.proj);
importedcomponents = CyPhyClasses.Components.Create(rf);
return(AVM2CyPhyML.CyPhyMLComponentBuilder.AVM2CyPhyML(importedcomponents, exportee));
}
public void TestAddMfgModelTool()
{
string TestName = System.Reflection.MethodBase.GetCurrentMethod().Name;
string path_Test = Path.Combine(testcreatepath, TestName);
string path_Mga = Path.Combine(path_Test, TestName + ".mga");
// delete any previous test results
if (Directory.Exists(path_Test))
{
Directory.Delete(path_Test, true);
}
// create a new blank project
MgaProject proj = new MgaProject();
proj.Create("MGA=" + path_Mga, "CyPhyML");
// these are the actual steps of the test
proj.PerformInTransaction(delegate
{
// create the environment for the Component authoring class
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder(proj);
CyPhy.Components components = CyPhyClasses.Components.Create(rf);
CyPhy.Component testcomp = CyPhyClasses.Component.Create(components);
// new instance of the class to test
CyPhyComponentAuthoring.Modules.MfgModelImport CATModule = new CyPhyComponentAuthoring.Modules.MfgModelImport();
//// these class variables need to be set to avoid NULL references
CATModule.SetCurrentDesignElement(testcomp);
CATModule.CurrentObj = testcomp.Impl as MgaFCO;
// call the primary function directly
CATModule.import_manufacturing_model(testmfgmdlpath);
// verify results
// 1. insure the mfg file was copied to the backend folder correctly
// insure the part file was copied to the backend folder correctly
var getmfgmdl = testcomp.Children.ManufacturingModelCollection.First();
string returnedpath;
getmfgmdl.TryGetResourcePath(out returnedpath, ComponentLibraryManager.PathConvention.ABSOLUTE);
string demanglepathpath = returnedpath.Replace("\\", "/");
Assert.True(File.Exists(demanglepathpath),
String.Format("Could not find the source file for the created resource, got {0}", demanglepathpath));
// 2. insure the resource path was created correctly
var mfgResource = testcomp.Children.ResourceCollection.Where(p => p.Name == "generic_cots_mfg.xml").First();
Assert.True(mfgResource.Attributes.Path == Path.Combine("Manufacturing", "generic_cots_mfg.xml"),
String.Format("{0} Resource should have had value {1}; instead found {2}", mfgResource.Name, "generic_cots_mfg.xml", mfgResource.Attributes.Path)
);
});
proj.Save();
proj.Close();
}
public static HashSet <CyPhyML.Component> getCyPhyMLComponentSet(CyPhyML.RootFolder cyPhyMLRootFolder)
{
HashSet <CyPhyML.Component> cyPhyMLComponentSet = new HashSet <CyPhyML.Component>();
foreach (CyPhyML.Components childComponentsFolder in cyPhyMLRootFolder.Children.ComponentsCollection)
{
cyPhyMLComponentSet.UnionWith(getCyPhyMLComponentSet(childComponentsFolder));
}
return(cyPhyMLComponentSet);
}
public void OutsideCopy_SameProjDir_MissingAVMID()
{
// Simulate copying a component from another MGA in the same project folder.
// It will have a Path unique to this project, and the path will already exist.
// However, it will be missing an AVMID.
// WHAT DO WE EXPECT THE ADDON TO DO?
// We expect it to assign a new AVMID, but change nothing else.
var compName = Utils.GetCurrentMethod();
// First, let's create such a path.
var path_ToCopy = Path.Combine(fixture.path_Test,
"components",
"z672jsd8");
var path_NewCopy = Path.Combine(fixture.path_Test,
"components",
compName);
Utils.DirectoryCopy(path_ToCopy, path_NewCopy);
// Now let's simulate copying a component from another project.
// It should have a Path, AVMID, and a Resource.
String org_AVMID = "";
String org_Path = "";
var project = fixture.GetProject();
project.EnableAutoAddOns(true);
project.PerformInTransaction(delegate
{
CyPhy.RootFolder rf = ISIS.GME.Dsml.CyPhyML.Classes.RootFolder.GetRootFolder(project);
CyPhy.Components cf = rf.Children.ComponentsCollection.First();
CyPhy.Component c = CyPhyClasses.Component.Create(cf);
c.Name = compName;
c.Attributes.AVMID = org_AVMID;
org_Path = c.Attributes.Path = Path.Combine("components", compName);
CyPhy.Resource res = CyPhyClasses.Resource.Create(c);
res.Attributes.Path = "generic_cots_mfg.xml";
res.Name = res.Attributes.Path;
});
project.PerformInTransaction(delegate
{
var c = project.GetComponentsByName(compName).FirstOrDefault();
Assert.True(org_AVMID != c.Attributes.AVMID, "A new AVMID should have been assigned.");
Assert.True(org_Path == c.Attributes.Path, "The path should not have been changed.");
});
project.Save();
}
public void OutsideCopy_SameProjDir()
{
// Create a new component.
// Its AVMID and Path will be unique to this project, and that path will exist already on disk.
// We expect that the Add-on isn't going to change anything.
var compName = Utils.GetCurrentMethod();
// First, let's create such a path.
var path_ToCopy = Path.Combine(fixture.path_Test,
"components",
"z672jsd8");
var path_NewCopy = Path.Combine(fixture.path_Test,
"components",
compName);
Utils.DirectoryCopy(path_ToCopy, path_NewCopy);
// Now let's simulate copying a component from another project.
// It should have a Path, AVMID, and a Resource.
String org_AVMID = "";
String org_Path = "";
var project = fixture.GetProject();
project.EnableAutoAddOns(true);
Assert.Contains("MGA.Addon.ComponentLibraryManagerAddOn", project.AddOnComponents.Cast <IMgaComponentEx>().Select(x => x.ComponentProgID));
project.PerformInTransaction(delegate
{
CyPhy.RootFolder rf = ISIS.GME.Dsml.CyPhyML.Classes.RootFolder.GetRootFolder(project);
CyPhy.Components cf = rf.Children.ComponentsCollection.First();
CyPhy.Component c = CyPhyClasses.Component.Create(cf);
c.Name = compName;
org_AVMID = c.Attributes.AVMID = Guid.NewGuid().ToString("D");
org_Path = c.Attributes.Path = Path.Combine("components", compName);
CyPhy.Resource res = CyPhyClasses.Resource.Create(c);
res.Attributes.Path = "generic_cots_mfg.xml";
res.Name = res.Attributes.Path;
});
project.PerformInTransaction(delegate
{
var c = project.GetComponentsByName(compName).FirstOrDefault();
Assert.True(org_AVMID == c.Attributes.AVMID, "AVMID was changed.");
Assert.True(org_Path == c.Attributes.Path, "Path was changed.");
});
project.Save();
}
public Model[] ImportFiles(string[] fileNames, DesignImportMode mode = AVMDesignImporter.DesignImportMode.CREATE_DS)
{
List <Model> ret = new List <Model>();
CyPhy.RootFolder rootFolder = ISIS.GME.Common.Utils.CreateObject <CyPhyClasses.RootFolder>(project.RootFolder as MgaObject);
Dictionary <string, CyPhy.Component> avmidComponentMap = CyPhyComponentImporterInterpreter.getCyPhyMLComponentDictionary_ByAVMID(rootFolder);
foreach (var inputFilePath in fileNames)
{
var container = ImportFile(inputFilePath, mode);
ret.Add(container);
}
return(ret.ToArray());
}
public static void init(CyPhyML.RootFolder rootFolder)
{
if (!isInitialized)
{
// Save the rootFolder
_cyPhyMLRootFolder = rootFolder;
// Add units to the dictionary
getCyPhyMLUnits();
getCyPhyMLNamedUnits();
isInitialized = true;
}
}
public void OutsideCopy_DifferentProjDir_AVMIDCollision()
{
// Create a new component.
// Its AVMID will NOT be unique to this project, and thus a new (unique) AVMID must be assigned.
// Its Path will be unique to this project, and that path will NOT exist already on disk,
// because we expect in this case that the component was copied from another project somewhere else.
// WHAT DO WE EXPECT THE ADD-ON TO DO?
// 1. Assign a new AVMID.
// 2. Because the folder does not exist on disk, a new path and backing folder will be created for this guy.
var compName = Utils.GetCurrentMethod();
// First, let's create a fake path.
var path_NewCopy = Path.Combine(fixture.path_Test,
"components",
compName);
// Now let's simulate copying a component from another project.
// It should have a Path, AVMID, and a Resource.
String org_AVMID = "";
String org_Path = "";
var project = fixture.GetProject();
project.EnableAutoAddOns(true);
project.PerformInTransaction(delegate
{
CyPhy.RootFolder rf = ISIS.GME.Dsml.CyPhyML.Classes.RootFolder.GetRootFolder(project);
CyPhy.Components cf = rf.Children.ComponentsCollection.First();
CyPhy.Component c = CyPhyClasses.Component.Create(cf);
c.Name = compName;
org_AVMID = c.Attributes.AVMID = "101b"; // This AVMID should collide
org_Path = c.Attributes.Path = Path.Combine("components", compName);
CyPhy.Resource res = CyPhyClasses.Resource.Create(c);
res.Attributes.Path = "generic_cots_mfg.xml";
res.Name = res.Attributes.Path;
});
project.PerformInTransaction(delegate
{
var c = project.GetComponentsByName(compName).FirstOrDefault();
Assert.True(org_AVMID != c.Attributes.AVMID, "A new AVMID should have been assigned.");
Assert.True(org_Path != c.Attributes.Path, "Component should have been assigned a new path.");
Assert.True(Directory.Exists(c.GetDirectoryPath(ComponentLibraryManager.PathConvention.ABSOLUTE)), "New component folder doesn't exist on disk.");
});
project.Save();
}
public void TestCADImportResourceNaming()
{
string TestName = System.Reflection.MethodBase.GetCurrentMethod().Name;
string path_Test = Path.Combine(testcreatepath, TestName);
string path_Mga = Path.Combine(path_Test, TestName + ".mga");
// delete any previous test results
if (Directory.Exists(path_Test))
{
Directory.Delete(path_Test, true);
}
// create a new blank project
MgaProject proj = new MgaProject();
proj.Create("MGA=" + path_Mga, "CyPhyML");
// these are the actual steps of the test
proj.PerformInTransaction(delegate
{
// create the environment for the Component authoring class
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder(proj);
CyPhy.Components components = CyPhyClasses.Components.Create(rf);
CyPhy.Component testcomp = CyPhyClasses.Component.Create(components);
// new instance of the class to test
CyPhyComponentAuthoring.Modules.CADModelImport testcam = new CyPhyComponentAuthoring.Modules.CADModelImport();
// these class variables need to be set to avoid NULL references
testcam.SetCurrentDesignElement(testcomp);
testcam.CurrentObj = testcomp.Impl as MgaFCO;
// call the module with a part file to skip the CREO steps
testcam.ImportCADModel(testpartpath);
// verify results
// insure the resource path was created correctly
var correct_name = testcomp.Children.ResourceCollection.Where(p => p.Name == "damper.prt").First();
Assert.True(correct_name.Attributes.Path == "CAD\\damper.prt",
String.Format("{0} should have had value {1}; instead found {2}", correct_name.Name, "CAD\\damper.prt", correct_name.Attributes.Path)
);
// insure the part file was copied to the back-end folder correctly
var getcadmdl = testcomp.Children.CADModelCollection.First();
string returnedpath;
getcadmdl.TryGetResourcePath(out returnedpath, ComponentLibraryManager.PathConvention.ABSOLUTE);
Assert.True(File.Exists(returnedpath + ".36"),
String.Format("Could not find the source file for the created resource, got {0}", returnedpath));
});
proj.Save();
proj.Close();
}
public void Import_NewStyle_NotITAR()
{
proj.PerformInTransaction(delegate
{
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder(proj);
CyPhy.Components cf = rf.Children.ComponentsCollection.First(f => f.Name == "Components");
avm.Component avmComp = new avm.Component()
{
Name = "Imported_NewStyle_NotITAR"
};
var cyphyComp = CyPhy2ComponentModel.Convert.AVMComponent2CyPhyML(cf, avmComp);
Assert.False(cyphyComp.Children.DistributionRestrictionCollection.Any());
});
}
public void TestComponentInstance()
{
// these are the actual steps of the test
fixture.proj.PerformInTransaction(delegate
{
// create the environment for the Component authoring class
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder(fixture.proj);
CyPhy.Component testcomp = fixture.proj.GetComponentsByName("JustAComponent").First();
string ret_msg;
// new instance of the class to test
CyPhyComponentAuthoring.CyPhyComponentAuthoringInterpreter testcai = new CyPhyComponentAuthoring.CyPhyComponentAuthoringInterpreter();
// these class variables need to be set to avoid NULL references
var CurrentObj = testcomp.Impl as MgaFCO;
// We are in a Component, check valid pre-conditions
Assert.True(testcai.CheckPreConditions(CurrentObj, out ret_msg),
String.Format("{0} should allow CAT to run in it, but it is not. Err=({1})", testcomp.Name, ret_msg)
);
// create a subcomponent and set it as current
CyPhy.Component testsubcomp = fixture.proj.GetComponentsByName("ComponentSubtype").First();
CurrentObj = testsubcomp.Impl as MgaFCO;
// We are in a sub-Component, check valid pre-conditions
Assert.True(testcai.CheckPreConditions(CurrentObj, out ret_msg),
String.Format("{0} should allow CAT to run in it, but it is not. Err=({1})", testsubcomp.Name, ret_msg)
);
// create a component instance and set it as current
CyPhy.Component testcompinst = fixture.proj.GetComponentsByName("ComponentInstance").First();
CurrentObj = testcompinst.Impl as MgaFCO;
// We are in a Component instance, check valid pre-conditions
Assert.False(testcai.CheckPreConditions(CurrentObj, out ret_msg),
String.Format("{0} should NOT allow CAT to run in it, yet it is. Err=({1})", testcompinst.Name, ret_msg)
);
// create a library object and set it as current
CyPhy.Component testlibcomp = fixture.proj.GetComponentsByName("LibComponent").First();
CurrentObj = testlibcomp.Impl as MgaFCO;
// We are in a library object, check valid pre-conditions
Assert.False(testcai.CheckPreConditions(CurrentObj, out ret_msg),
String.Format("{0} should NOT allow CAT to run in it, yet it is. Err=({1})", testlibcomp.Name, ret_msg)
);
});
}
public static CyPhyML.unit getCyPhyMLUnitFromString(string units, CyPhyML.RootFolder rootFolder)
{
CyPhyML.unit rVal = null;
init(rootFolder);
if (!String.IsNullOrWhiteSpace(units))
{
if (_unitSymbolCyPhyMLUnitMap.ContainsKey(units))
{
rVal = _unitSymbolCyPhyMLUnitMap[units];
}
else
{
// writeMessage(String.Format("WARNING: No unit lib match found for: {0}", units), MessageType.WARNING);
}
}
return(rVal);
}
public void TestCATDialogBoxCentering()
{
// these are the actual steps of the test
fixture.proj.PerformInTransaction(delegate
{
// create the environment for the Component authoring class
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder(fixture.proj);
CyPhy.Component testcomp = fixture.proj.GetComponentsByName("JustAComponent").First();
// new instance of the class to test
CyPhyComponentAuthoring.CyPhyComponentAuthoringInterpreter testcai = new CyPhyComponentAuthoring.CyPhyComponentAuthoringInterpreter();
// Call the create dialog box method
testcai.PopulateDialogBox(true);
// Get the dialog box location and verify it is in the center of the screen
Assert.True(testcai.ThisDialogBox.StartPosition == FormStartPosition.CenterScreen,
String.Format("CAT dialog box is not in the center of the screen")
);
});
}
private CyPhy.Components GetImportFolder(CyPhy.RootFolder rf)
{
CyPhy.Components rtn = null;
foreach (CyPhy.Components c in rf.Children.ComponentsCollection)
{
if (c.Name == ImportedComponentsFolderName)
{
rtn = c;
break;
}
}
if (rtn == null)
{
rtn = CyPhyClasses.Components.Create(rf);
rtn.Name = ImportedComponentsFolderName;
}
return(rtn);
}
private static CyPhy.Components DetermineAndEnsureFolderForComponent(CyPhy.RootFolder rootFolder, avm.Component ac_import)
{
// Get or create a root Components folder. Components will go in here, unless they have a classification.
CyPhy.Components cyPhyMLComponentsFolder = rootFolder.Children.ComponentsCollection
.FirstOrDefault(cf => cf.Name.Equals(ImportedComponentsFolderName));
if (cyPhyMLComponentsFolder == null)
{
cyPhyMLComponentsFolder = CyPhyClasses.Components.Create(rootFolder);
cyPhyMLComponentsFolder.Name = ImportedComponentsFolderName;
}
// Check for classifications. If the component has 1 or more classifications, then
// the first one will be used to find/build a corresponding folder structure for this component.
if (ac_import.Classifications.Count > 0 &&
!String.IsNullOrWhiteSpace(ac_import.Classifications.FirstOrDefault()))
{
var firstClass = ac_import.Classifications.FirstOrDefault();
// Create an iterator and initialize it on the root Components folder.
CyPhy.Components folIter = cyPhyMLComponentsFolder;
foreach (var folName in firstClass.Split('.'))
{
// Find a child folder with this name
var tmp = folIter.Children.ComponentsCollection
.FirstOrDefault(cf => cf.Name.Equals(folName));
// If no folder by that name, create one.
if (tmp == null)
{
tmp = CyPhyClasses.Components.Create(folIter);
tmp.Name = folName;
}
// Set this folder as the current, and move to the next category.
folIter = tmp;
}
cyPhyMLComponentsFolder = folIter;
}
return(cyPhyMLComponentsFolder);
}
public void Import_NewStyle_ITAR()
{
proj.PerformInTransaction(delegate
{
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder(proj);
CyPhy.Components cf = rf.Children.ComponentsCollection.First(f => f.Name == "Components");
avm.Component avmComp = new avm.Component()
{
Name = "Imported_NewStyle_ITAR"
};
avmComp.DistributionRestriction.Add(new avm.ITAR());
var cyphyComp = CyPhy2ComponentModel.Convert.AVMComponent2CyPhyML(cf, avmComp);
var itarCollection = cyphyComp.Children.ITARCollection;
Assert.True(itarCollection.Count() == 1);
Assert.True(itarCollection.First().Attributes.RestrictionLevel == CyPhyClasses.ITAR.AttributesClass.RestrictionLevel_enum.ITAR);
Assert.False(cyphyComp.Children.DoDDistributionStatementCollection.Any());
});
}
public IMgaFCO CreateComponentForAcm(MgaProject project, string filename)
{
Component ac_import;
InitializeLogger(project);
using (Logger)
{
using (StreamReader streamReader = new StreamReader(filename))
{
ac_import = this.DeserializeAvmComponentXml_NonStatic(streamReader);
}
if (ac_import == null)
{
throw new Exception("Could not load ACM file.");
}
CyPhy.RootFolder rootFolder = ISIS.GME.Common.Utils.CreateObject <CyPhyClasses.RootFolder>(project.RootFolder as MgaObject);
var cyPhyMLComponentsFolder = DetermineAndEnsureFolderForComponent(rootFolder, ac_import);
var c = CyPhy2ComponentModel.Convert.AVMComponent2CyPhyML(cyPhyMLComponentsFolder, ac_import, true, Logger);
return((IMgaFCO)c.Impl);
}
}
private CyPhy.DesignContainer CreateDesignSpaceRoot(avm.Design ad_import)
{
CyPhy.DesignSpace ds;
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder((MgaProject)project);
ds = rf.Children.DesignSpaceCollection.Where(d => d.Name == "DesignSpaces").FirstOrDefault();
if (ds == null)
{
ds = CyPhyClasses.DesignSpace.Create(rf);
ds.Name = "DesignSpaces";
}
CyPhy.DesignContainer cyphy_container = CyPhyClasses.DesignContainer.Create(ds);
// container.Name = ad_import.Name; RootContainer has a name too
int designID;
if (int.TryParse(ad_import.DesignID, out designID))
{
cyphy_container.Attributes.ID = designID;
}
cyphy_container.Attributes.ContainerType = CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound;
return(cyphy_container);
}
/// <summary>
/// Call this function within a transaction!
/// </summary>
/// <param name="outputDirectory"></param>
/// <param name="project"></param>
/// <param name="rootDS"></param>
/// <param name="textWriter"></param>
/// <returns></returns>
public static MetaAvmProject Create(
string outputDirectory,
MgaProject project = null,
MgaModel rootDS = null,
GME.CSharp.GMEConsole console = null
)
{
MetaAvmProject avmProj = new MetaAvmProject();
outputDirectory = Path.GetFullPath(outputDirectory);
Directory.CreateDirectory(outputDirectory);
string avmProjFileName = Path.GetFullPath(Path.Combine(outputDirectory, "manifest.project.json"));
using (new MutexWrapper(avmProjFileName))
{
if (File.Exists(avmProjFileName))
{
string sjson = "{}";
using (StreamReader reader = new StreamReader(avmProjFileName))
{
sjson = reader.ReadToEnd();
try
{
avmProj = JsonConvert.DeserializeObject <AVM.DDP.MetaAvmProject>(sjson);
}
catch (Newtonsoft.Json.JsonReaderException ex)
{
throw new Exception(string.Format("{0} file is probably malformed. Not a valid json. {1}{2}", Path.GetFullPath(avmProjFileName), Environment.NewLine, ex.Message));
}
}
}
}
if (console != null)
{
avmProj.infoTextWriter = console.Info;
avmProj.errorTextWriter = console.Error;
}
avmProj.OutputDirectory = outputDirectory;
avmProj.m_filename = avmProjFileName;
avmProj.Project.LastModified = DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss");
if (avmProj.Project.Results.UrlHints.Contains("./results/results.metaresults.json") == false)
{
avmProj.Project.Results.UrlHints.Add("./results/results.metaresults.json");
}
if (avmProj.Project.Requirements.UrlHints.Contains("./requirements/requirements.json") == false)
{
avmProj.Project.Requirements.UrlHints.Add("./requirements/requirements.json");
}
string reqSourceRepository = string.Empty;
string reqId = string.Empty;
string reqText = string.Empty;
if (project != null)
{
avmProj.Project.CyPhyProjectFileName = MgaExtensions.MgaExtensions.GetProjectName(project);
CyPhy.RootFolder rf = ISIS.GME.Dsml.CyPhyML.Classes.RootFolder.GetRootFolder(project);
var topLevelLinks = rf.Children.RequirementsCollection
.SelectMany(x => x.Children.RequirementLinkCollection);
var defaults = topLevelLinks.Where(x => x.Name.ToLowerInvariant() == "default");
var reqDefault = defaults.FirstOrDefault();
if (defaults.Count() > 1)
{
// more requ found first one will be used
string msg = string.Format("More than one Requirement was not found {0} in use.", reqDefault.Impl.AbsPath);
Trace.TraceWarning(msg);
avmProj.infoTextWriter.WriteLine(msg);
}
if (reqDefault != null)
{
reqSourceRepository = reqDefault.Attributes.SourceRepository;
reqId = reqDefault.Attributes.ID;
reqText = reqDefault.Attributes.Text;
}
else
{
// requ not found
string msg = "Requirement was not found.";
Trace.TraceWarning(msg);
// RESTORE THIS MESSAGE ONCE WE SWITCH TO USING GMELOGGER
// avmProj.infoTextWriter.WriteLine(msg);
}
}
avmProj.Project.Requirements.vfLink = reqSourceRepository;
avmProj.Project.Requirements.id = reqId;
avmProj.Project.Requirements.text = reqText;
string dirName = Path.Combine(outputDirectory, "requirements");
if (Directory.Exists(dirName) == false)
{
Directory.CreateDirectory(dirName);
string requFileName = Path.GetFullPath(Path.Combine(dirName, "requirements.json"));
using (new MutexWrapper(requFileName))
{
if (File.Exists(requFileName) == false)
{
using (StreamWriter writer = new StreamWriter(requFileName))
{
// default requirement
writer.WriteLine(@"{");
writer.WriteLine(" \"name\": \"Undefined\",");
writer.WriteLine(" \"children\": []");
writer.WriteLine(@"}");
}
}
}
}
string designSpaceFolder = "design-space";
dirName = Path.GetFullPath(Path.Combine(outputDirectory, designSpaceFolder));
Directory.CreateDirectory(dirName);
if (rootDS != null)
{
// export designspace
var dsProjectJsonLink = Path.Combine(".", designSpaceFolder, rootDS.Name + ".adm").Replace('\\', '/');
var dsFileName = Path.Combine(dirName, rootDS.Name + ".adm");
if (avmProj.Project.DesignSpaceModels.Contains(dsProjectJsonLink) == false)
{
avmProj.Project.DesignSpaceModels.Add(dsProjectJsonLink);
}
var designContainer = ISIS.GME.Dsml.CyPhyML.Classes.DesignContainer.Cast(rootDS);
var design = CyPhy2DesignInterchange.CyPhy2DesignInterchange.Convert(designContainer);
using (new MutexWrapper(dsFileName))
{
design.SaveToFile(dsFileName);
}
}
return(avmProj);
}
public void Main(MgaProject project, MgaFCO currentobj, MgaFCOs selectedobjs, ComponentStartMode startMode)
{
Boolean disposeLogger = false;
if (Logger == null)
{
Logger = new CyPhyGUIs.GMELogger(project, "CyPhyDesignExporter");
disposeLogger = true;
}
// TODO: Add your interpreter code
Logger.WriteInfo("Running Design Exporter...");
#region Prompt for Output Path
// Get an output path from the user.
if (this.OutputDir == null)
{
using (META.FolderBrowserDialog fbd = new META.FolderBrowserDialog()
{
Description = "Choose a path for the generated files.",
//ShowNewFolderButton = true,
SelectedPath = Environment.CurrentDirectory,
})
{
DialogResult dr = fbd.ShowDialog();
if (dr == DialogResult.OK)
{
OutputDir = fbd.SelectedPath;
}
else
{
Logger.WriteWarning("Design Exporter cancelled");
return;
}
}
}
#endregion
Logger.WriteInfo("Beginning Export...");
List <CyPhy.DesignEntity> lde_allCAandDC = new List <CyPhy.DesignEntity>();
List <CyPhy.TestBenchType> ltbt_allTB = new List <CyPhy.TestBenchType>();
if (currentobj != null &&
currentobj.Meta.Name == "ComponentAssembly")
{
lde_allCAandDC.Add(CyPhyClasses.ComponentAssembly.Cast(currentobj));
}
else if (currentobj != null &&
currentobj.Meta.Name == "DesignContainer")
{
lde_allCAandDC.Add(CyPhyClasses.DesignContainer.Cast(currentobj));
}
else if (currentobj != null &&
IsTestBenchType(currentobj.MetaBase.Name))
{
ltbt_allTB.Add(CyPhyClasses.TestBenchType.Cast(currentobj));
}
else if (selectedobjs != null && selectedobjs.Count > 0)
{
foreach (MgaFCO mf in selectedobjs)
{
if (mf.Meta.Name == "ComponentAssembly")
{
lde_allCAandDC.Add(CyPhyClasses.ComponentAssembly.Cast(mf));
}
else if (mf.Meta.Name == "DesignContainer")
{
lde_allCAandDC.Add(CyPhyClasses.DesignContainer.Cast(mf));
}
else if (IsTestBenchType(mf.MetaBase.Name))
{
ltbt_allTB.Add(CyPhyClasses.TestBenchType.Cast(mf));
}
}
}
else
{
CyPhy.RootFolder rootFolder = ISIS.GME.Common.Utils.CreateObject <CyPhyClasses.RootFolder>(project.RootFolder as MgaObject);
MgaFilter filter = project.CreateFilter();
filter.Kind = "ComponentAssembly";
foreach (var item in project.AllFCOs(filter).Cast <MgaFCO>())
{
if (item.ParentFolder != null)
{
lde_allCAandDC.Add(CyPhyClasses.ComponentAssembly.Cast(item));
}
}
filter = project.CreateFilter();
filter.Kind = "DesignContainer";
foreach (var item in project.AllFCOs(filter).Cast <MgaFCO>())
{
if (item.ParentFolder != null)
{
lde_allCAandDC.Add(CyPhyClasses.DesignContainer.Cast(item));
}
}
filter = project.CreateFilter();
filter.Kind = "TestBenchType";
foreach (var item in project.AllFCOs(filter).Cast <MgaFCO>())
{
if (item.ParentFolder != null)
{
ltbt_allTB.Add(CyPhyClasses.TestBenchType.Cast(item));
}
}
}
foreach (CyPhy.DesignEntity de in lde_allCAandDC)
{
System.Windows.Forms.Application.DoEvents();
try
{
if (de is CyPhy.ComponentAssembly)
{
ExportToPackage(de as CyPhy.ComponentAssembly, OutputDir);
}
else
{
ExportToFile(de, OutputDir);
}
}
catch (Exception ex)
{
Logger.WriteError("{0}: Exception encountered ({1})", de.Name, ex.Message);
}
Logger.WriteInfo("{0}: {1}", de.Name, OutputDir);
}
foreach (CyPhy.TestBenchType tbt in ltbt_allTB)
{
System.Windows.Forms.Application.DoEvents();
try
{
ExportToFile(tbt, OutputDir);
}
catch (Exception ex)
{
Logger.WriteError("{0}: Exception encountered ({1})", tbt.Name, ex.Message);
}
Logger.WriteInfo("{0}: {1}", tbt.Name, OutputDir);
}
Logger.WriteInfo(String.Format("{0} model(s) exported", lde_allCAandDC.Count + ltbt_allTB.Count));
Logger.WriteInfo("Design Exporter finished");
if (disposeLogger)
{
DisposeLogger();
}
}
private static Dictionary <string, CyPhy.Component> getCyPhyMLComponentDictionary_ByName(CyPhy.RootFolder cyPhyMLRootFolder)
{
var rtn = new Dictionary <string, CyPhy.Component>();
var project = cyPhyMLRootFolder.Impl.Project;
MgaFilter filter = project.CreateFilter();
filter.Kind = "Component";
foreach (var item in project.AllFCOs(filter).Cast <MgaFCO>().Where(x => x.ParentFolder != null))
{
var comp = CyPhyClasses.Component.Cast(item);
rtn[comp.Name] = comp;
}
return(rtn);
}
public ModelicaModelPicker(
bool createMultipleComponents,
MgaProject thisProject,
CyPhyGUIs.GMELogger logger,
CyPhy.ComponentType cyphyComponent=null)
{
this.InitializeComponent();
this.componentDetails = new List<ComponentDetail>();
this.externalPackagePaths = new List<string>();
this.externalPackageNames = new List<string>();
this.UpdateModelPickerDataSource_detailed();
this.m_Logger = logger;
this.m_Project = thisProject;
this.m_createMultipleComponents = createMultipleComponents;
this.dgvModelPicker.MultiSelect = true;
//string testFilePath = "";
//if (File.Exists(testFilePath))
//{
// this.ReadFileAndImportComponents_Flat(testFilePath);
// return;
//}
if (this.m_createMultipleComponents)
{
this.gbComponentType.Visible = true;
this.btnImportSelected.Text = "Import Selected Component(s)";
}
if (!this.m_createMultipleComponents &&
cyphyComponent != null)
{
this.m_CyPhyComponent = cyphyComponent;
}
this.pictureBoxLoader.Visible = false;
this.btnImportSelected.Enabled = false;
this.btnViewWebDoc.Enabled = false;
this.cbIncludeMSL.Checked = true;
this.cbIncludeMSL.Enabled = false;
lbExternalLibList.Items.Add("ModelicaStandardLibrary");
this.rootFolder = CyPhyClasses.RootFolder.GetRootFolder(this.m_Project);
if (this.rootFolder != null)
{
this.localConnectorLibrary =
this.rootFolder.Children.ConnectorsCollection.FirstOrDefault(x => x.Name == "ImportedConnectors");
if (this.localConnectorLibrary != null)
{
this.localPortLibrary =
this.localConnectorLibrary.Children.PortsCollection.FirstOrDefault(x =>
x.Name == "ImportedPortTypes");
if (this.localPortLibrary != null)
{
this.localPortMap =
this.localPortLibrary.Children.ModelicaConnectorCollection.ToDictionary(mc => mc.Attributes.Class);
}
else
{
this.localPortLibrary = CyPhyClasses.Ports.Create(this.localConnectorLibrary);
this.localPortLibrary.Name = "ImportedPortTypes";
this.localPortMap = new Dictionary<string, CyPhy.ModelicaConnector>();
}
}
else
{
this.localConnectorLibrary = CyPhyClasses.Connectors.Create(this.rootFolder);
this.localConnectorLibrary.Name = "ImportedConnectors";
this.localPortLibrary = CyPhyClasses.Ports.Create(this.localConnectorLibrary);
this.localPortLibrary.Name = "ImportedPortTypes";
this.localPortMap = new Dictionary<string, CyPhy.ModelicaConnector>();
}
}
else
{
this.m_Logger.WriteError("Could not get the root folder!");
return;
}
this.backgroundWorkerTreeImport.DoWork += backgroundWorkerTreeImport_DoWork;
this.backgroundWorkerTreeImport.RunWorkerCompleted += backgroundWorkerTreeImport_RunWorkerCompleted;
this.backgroundWorkerComponentImport.DoWork += backgroundWorkerComponentImport_DoWork;
this.backgroundWorkerComponentImport.RunWorkerCompleted += backgroundWorkerComponentImport_RunWorkerCompleted;
this.numModelicaModels = 0;
this.numComponentParams = 0;
this.numModelicaParams = 0;
this.numComponentPorts = 0;
this.numModelicaPorts = 0;
}
public static int Main(String[] args)
{
if (args.Length < 2 || args.Length > 4)
{
usage();
return(1);
}
MgaProject mgaProject;
List <String> lp_FilesToImport = new List <string>();
string avmFilePath = "";
string mgaProjectPath = "";
string componentReplacementPath = "";
bool rOptionUsed = false;
bool pOptionUsed = false;
for (int ix = 0; ix < args.Length; ++ix)
{
if (args[ix].ToLower() == "-r")
{
if (pOptionUsed)
{
usage();
return(1);
}
rOptionUsed = true;
if (++ix >= args.Length)
{
usage();
return(1);
}
if (avmFilePath != null && avmFilePath != "")
{
if (mgaProjectPath != null && mgaProjectPath != "")
{
usage();
return(1);
}
mgaProjectPath = avmFilePath;
avmFilePath = "";
lp_FilesToImport.Clear();
}
String sImportDirectory = args[ix];
String startingDirectory = Path.GetFullPath(sImportDirectory);
string[] xmlFiles = Directory.GetFiles(startingDirectory, "*.acm", SearchOption.AllDirectories);
foreach (String p_XMLFile in xmlFiles)
{
lp_FilesToImport.Add(Path.GetFullPath(p_XMLFile));
}
}
else if (args[ix].ToLower() == "-p")
{
if (rOptionUsed)
{
usage();
return(1);
}
pOptionUsed = true;
if (++ix >= args.Length)
{
usage();
return(1);
}
componentReplacementPath = args[ix];
}
else if (lp_FilesToImport.Count == 0 && avmFilePath == "")
{
avmFilePath = args[ix];
try
{
lp_FilesToImport.Add(Path.GetFullPath(avmFilePath));
}
catch (System.ArgumentException ex)
{
Console.Out.WriteLine(ex.Message);
Console.Out.WriteLine(avmFilePath);
throw ex;
}
}
else
{
if (mgaProjectPath != null && mgaProjectPath != "")
{
usage();
return(1);
}
mgaProjectPath = args[ix];
}
}
mgaProject = GetProject(mgaProjectPath);
try
{
bool bExceptionOccurred = false;
if (mgaProject != null)
{
MgaGateway mgaGateway = new MgaGateway(mgaProject);
mgaGateway.PerformInTransaction(delegate
{
string libroot = Path.GetDirectoryName(Path.GetFullPath(mgaProjectPath));
CyPhyML.RootFolder cyPhyMLRootFolder = ISIS.GME.Common.Utils.CreateObject <CyPhyMLClasses.RootFolder>(mgaProject.RootFolder as MgaObject);
#region Attach QUDT library if needed
IMgaFolder oldQudt = mgaProject.RootFolder.ChildFolders.Cast <IMgaFolder>().Where(x => x.LibraryName != "" && (x.Name.ToLower().Contains("qudt"))).FirstOrDefault();
string mgaQudtPath = Meta_Path + "\\meta\\CyPhyMLQudt.mga";
bool needAttach = false;
if (oldQudt == null)
{
needAttach = true;
}
else
{
long loldModTime;
DateTime oldModTime = long.TryParse(oldQudt.RegistryValue["modtime"], out loldModTime) ? DateTime.FromFileTimeUtc(loldModTime) : DateTime.MinValue;
needAttach = System.IO.File.GetLastWriteTimeUtc(mgaQudtPath).CompareTo(oldModTime) > 0;
if (!needAttach)
{
Console.Error.WriteLine("QUDT is up-to-date: embedded library modified " + oldModTime.ToString() + ", CyPhyMLQudt.mga modified " + System.IO.File.GetLastWriteTimeUtc(mgaQudtPath).ToString());
}
}
if (needAttach)
{
Console.Error.WriteLine("Attaching library " + mgaQudtPath);
ISIS.GME.Common.Interfaces.RootFolder newQudt = ISIS.GME.Common.Classes.RootFolder.GetRootFolder(mgaProject).AttachLibrary("MGA=" + mgaQudtPath);
DateTime modtime = System.IO.File.GetLastWriteTimeUtc(mgaQudtPath);
((newQudt as ISIS.GME.Common.Classes.RootFolder).Impl as GME.MGA.IMgaFolder).RegistryValue["modtime"] =
modtime.ToFileTimeUtc().ToString();
if (oldQudt != null)
{
ReferenceSwitcher.Switcher sw = new ReferenceSwitcher.Switcher(oldQudt, newQudt.Impl, null);
sw.UpdateSublibrary();
oldQudt.DestroyObject();
}
((newQudt as ISIS.GME.Common.Classes.RootFolder).Impl as GME.MGA.IMgaFolder).LibraryName = "UnitLibrary QUDT";
Console.Error.WriteLine((oldQudt == null ? "Attached " : "Refreshed") + " Qudt library.");
}
#endregion
var importer = new CyPhyComponentImporter.CyPhyComponentImporterInterpreter();
importer.Initialize(cyPhyMLRootFolder.Impl.Project);
importer.ImportFiles(cyPhyMLRootFolder.Impl.Project, libroot, lp_FilesToImport.ToArray(), true);
importer.DisposeLogger();
bExceptionOccurred = importer.Errors.Count > 0;
}, abort: false);
mgaProject.Save();
if (bExceptionOccurred)
{
return(-1);
}
}
}
finally
{
mgaProject.Close(true);
}
return(0);
}
public IMgaFCOs ImportFiles(MgaProject project, string projRootPath, string[] FileNames, bool alwaysReplace = false, bool doNotReplaceAll = false)
{
Boolean b_CLMAddOnStatus = META.ComponentLibraryManagerAddOn.GetEnabled(project);
META.ComponentLibraryManagerAddOn.Enable(false, project);
var addons = project.AddOnComponents.Cast <IMgaComponentEx>();
foreach (var addon in addons)
{
if (addon.ComponentName.ToLowerInvariant() == "CyPhyAddOn".ToLowerInvariant())
{
addon.ComponentParameter["DontAssignGuidsOnNextTransaction".ToLowerInvariant()] = true;
}
}
IMgaFCOs importedComponents = (IMgaFCOs)Activator.CreateInstance(Type.GetTypeFromProgID("Mga.MgaFCOs"));
try
{
bool replaceAll = alwaysReplace;
CyPhy.RootFolder rootFolder = ISIS.GME.Common.Utils.CreateObject <CyPhyClasses.RootFolder>(project.RootFolder as MgaObject);
Dictionary <string, CyPhy.Component> avmidComponentMap = getCyPhyMLComponentDictionary_ByAVMID(rootFolder);
Dictionary <string, CyPhy.Component> nameComponentMap = getCyPhyMLComponentDictionary_ByName(rootFolder);
Boolean b_FirstComponent = true;
foreach (String inputFile in FileNames)
{
var inputFilePath = inputFile;
/* Disable validation for now
#region Check validation rules
*
* var errorMessages = new List<string>();
* ComponentImportRules.CheckUniqueNames(inputXMLFile, ref errorMessages);
* var isValid = ComponentImportRules.ValidateXsd(inputXMLFile, ref errorMessages);
*
* foreach (var errorMessage in errorMessages)
* {
* GMEConsole.Error.WriteLine(errorMessage);
* }
*
* if (!isValid)
* {
* GMEConsole.Info.WriteLine("XML is not valid. Skip file: {0}", inputXMLFile);
* continue;
* }
#endregion
*/
GMEConsole.Info.WriteLine("Importing {0}", inputFilePath);
// If ZIP file, unzip it to a temporary directory, then import as usual
UnzipToTemp unzip = null;
bool bZipArchive = (Path.GetExtension(inputFilePath) == ".zip");
if (bZipArchive)
{
unzip = new UnzipToTemp(GMEConsole);
List <string> entries = unzip.UnzipFile(inputFilePath);
inputFilePath = entries.Where(entry => Path.GetDirectoryName(entry) == "" && entry.EndsWith(".acm")).FirstOrDefault();
if (inputFilePath != null)
{
inputFilePath = Path.Combine(unzip.TempDirDestination, inputFilePath);
}
}
using (unzip)
try
{
if (inputFilePath == null) // may be null if .zip didn't contain .acm
{
throw new FileNotFoundException("No ACM file not found in root directory of ZIP file.");
}
avm.Component ac_import = null;
/* META-3003: Check for old-style ITAR statement */
bool isDistributionD = false;
bool isNotItar = false;
#region Check for old-style ITAR statements
XmlDocument doc = new XmlDocument();
doc.Load(inputFilePath);
XmlNode root = doc.DocumentElement;
XmlNodeList nodeList = root.SelectNodes("//*[local-name()='DistributionRestriction' and @Level='ITARDistributionD']");
if (nodeList.Count > 0)
{
isDistributionD = true;
}
else
{
nodeList = root.SelectNodes("//*[local-name()='DistributionRestriction' and @Level='NotITAR']");
if (nodeList.Count > 0)
{
isNotItar = true;
}
}
#endregion
using (StreamReader streamReader = new StreamReader(inputFilePath))
{
ac_import = DeserializeAvmComponentXml(streamReader);
}
if (ac_import == null)
{
throw new Exception("Could not load ACM file.");
}
/* Throw warning if from an unexpected schema version */
CheckAndWarnOnSchemaVersion(ac_import);
/* META-3003: Strip old-style ITAR statement */
#region Strip old-style ITAR statements
if (isDistributionD)
{
// Correct this.
if (ac_import.DistributionRestriction == null)
{
ac_import.DistributionRestriction = new List <avm.DistributionRestriction>();
}
ac_import.DistributionRestriction.Add(new avm.DoDDistributionStatement()
{
Type = DoDDistributionStatementEnum.StatementD
});
}
else if (isNotItar)
{
var itar = ac_import.DistributionRestriction.OfType <avm.ITAR>().FirstOrDefault();
if (itar != null)
{
ac_import.DistributionRestriction.Remove(itar);
}
}
#endregion
String acmDir = Path.GetDirectoryName(inputFilePath);
#region File Management
// Create a new backend folder
String compDirAbsPath = META.ComponentLibraryManager.CreateComponentFolder(project);
String compDirRelPath = MetaAvmProject.MakeRelativePath(projRootPath, compDirAbsPath);
// Copy the ACM file to the new path
String newACMRelPath = Path.Combine(compDirRelPath, ac_import.Name + ".acm");
string newACMAbsPath = Path.Combine(compDirAbsPath, ac_import.Name + ".acm");
File.Copy(inputFilePath, newACMAbsPath, true);
// Now we have to copy in his resources
foreach (var resource in ac_import.ResourceDependency)
{
try
{
var dirRelPath = Path.GetDirectoryName(resource.Path);
var dirAbsPath = Path.Combine(compDirAbsPath, dirRelPath);
var orgAbsPath = Path.Combine(acmDir, resource.Path);
var dstAbsPath = Path.Combine(compDirAbsPath, resource.Path);
Directory.CreateDirectory(dirAbsPath);
File.Copy(orgAbsPath, dstAbsPath, true);
}
catch (FileNotFoundException)
{
var message = String.Format("This Component depends on a file which cannot be found in the Component package: {0}", resource.Path);
GMEConsole.Warning.WriteLine(message);
}
catch (DirectoryNotFoundException)
{
var message = String.Format("This Component depends on a file which cannot be found in the Component package: {0}", resource.Path);
GMEConsole.Warning.WriteLine(message);
}
catch (PathTooLongException)
{
var message = String.Format("This Component has a Resource that results in a path that is too long: {0}", resource.Path);
GMEConsole.Warning.WriteLine(message);
}
catch (NotSupportedException)
{
var message = String.Format("This Component has a Resource that could not be loaded: {0}", resource.Path);
GMEConsole.Warning.WriteLine(message);
}
catch (Exception ex)
{
var message = String.Format("Exception while copying Resource {0}: {1}", resource.Path, ex);
GMEConsole.Warning.WriteLine(message);
}
}
#endregion
CyPhy.ComponentAssembly cyPhyMLComponentAssembly = null;
CyPhy.Components cyPhyMLComponentsFolder = null;
CyPhy.Component cyPhyReplaceComponent = null;
#region Search for Components that should be Replaced by this new one
bool replaceeFound = false;
if (ac_import.ID != null)
{
replaceeFound = avmidComponentMap.TryGetValue(ac_import.ID, out cyPhyReplaceComponent);
}
if (replaceeFound == false)
{
replaceeFound = nameComponentMap.TryGetValue(ac_import.Name, out cyPhyReplaceComponent);
}
if (replaceeFound)
{
bool replace = false;
if (!doNotReplaceAll && !replaceAll)
{
// Present dialog to see if user wants to replace component with AVMID avmid
// Maybe have a "do all" checkbox (which sets "replaceAll" to "true") if many items are being imported.
// If yes, replace = true;
String s_ExistingName = cyPhyReplaceComponent.Name;
String s_ExistingAVMID = cyPhyReplaceComponent.Attributes.AVMID;
String s_ExistingVersion = cyPhyReplaceComponent.Attributes.Version;
String s_ExistingRevision = cyPhyReplaceComponent.Attributes.Revision;
String s_ExistingDescriptor = cyPhyReplaceComponent.Name;
if (s_ExistingAVMID != "")
{
s_ExistingDescriptor += "\nAVM ID: " + s_ExistingAVMID;
}
if (s_ExistingVersion != "")
{
s_ExistingDescriptor += "\nVersion: " + s_ExistingVersion;
}
if (s_ExistingRevision != "")
{
s_ExistingDescriptor += "\nRevision: " + s_ExistingRevision;
}
String s_NewName = ac_import.Name;
//String s_NewAVMID = ac_import.AVMID;
String s_NewVersion = ac_import.Version;
//String s_NewRevision = ac_import.Revision;
String s_NewDescriptor = ac_import.Name;
//if (s_NewAVMID != "")
// s_NewDescriptor += "\nAVM ID: " + s_NewAVMID;
if (s_NewVersion != "")
{
s_NewDescriptor += "\nVersion: " + s_NewVersion;
}
//if (s_NewRevision != "")
// s_NewDescriptor += "\nRevision: " + s_NewRevision;
String s_MessageBoxPromptTemplate = "Would you like to replace\n\n{0}\n\nwith\n\n{1}";
String s_MessageBoxPrompt = String.Format(s_MessageBoxPromptTemplate, s_ExistingDescriptor, s_NewDescriptor);
using (UpdatePrompt up = new UpdatePrompt())
{
up.DialogText.Text = s_MessageBoxPrompt;
up.ShowDialog();
if (up.DialogResult == DialogResult.Cancel ||
up.DialogResult == DialogResult.None)
{
// Skip this component; Continues the "foreach" loop above.
GMEConsole.Error.WriteLine("Import canceled for {0}", inputFile);
continue;
}
Dictionary <DialogResult, string> d_TranslateResult = new Dictionary <DialogResult, string>()
{
{ DialogResult.OK, "Replace" },
{ DialogResult.Abort, "Import as New" },
};
if (d_TranslateResult[up.DialogResult] == "Replace")
{
replace = true;
if (up.applyToAll.Checked)
{
replaceAll = true;
}
}
else if (d_TranslateResult[up.DialogResult] == "Import as New")
{
if (up.applyToAll.Checked)
{
doNotReplaceAll = true;
}
}
}
}
if (!replace && !replaceAll || doNotReplaceAll)
{
cyPhyReplaceComponent = null;
}
}
#endregion
if (cyPhyReplaceComponent != null)
{
Object replaceComponentParent = cyPhyReplaceComponent.ParentContainer;
if (replaceComponentParent is CyPhy.ComponentAssembly)
{
cyPhyMLComponentAssembly = replaceComponentParent as CyPhy.ComponentAssembly;
}
else
{
cyPhyMLComponentsFolder = replaceComponentParent as CyPhy.Components;
}
}
else
{
cyPhyMLComponentsFolder = GetImportFolder(rootFolder);
}
// The importer uses a map to resolve unit references.
// If this is our second run, we shouldn't waste time rebuilding it.
Boolean b_ResetUnitMap;
if (b_FirstComponent)
{
b_ResetUnitMap = true;
}
else
{
b_ResetUnitMap = false;
}
CyPhy.Component c = null;
if (cyPhyMLComponentAssembly != null)
{
c = CyPhy2ComponentModel.Convert.AVMComponent2CyPhyML(cyPhyMLComponentAssembly, ac_import, b_ResetUnitMap, GMEConsole);
}
else
{
c = CyPhy2ComponentModel.Convert.AVMComponent2CyPhyML(cyPhyMLComponentsFolder, ac_import, b_ResetUnitMap, GMEConsole);
}
if (c != null)
{
importedComponents.Append(c.Impl as MgaFCO);
c.Attributes.Path = compDirRelPath;
}
if (cyPhyReplaceComponent != null)
{
foreach (IMgaReference reference in (cyPhyReplaceComponent.Impl as IMgaFCO).ReferencedBy)
{
ReferenceSwitcher.Switcher.MoveReferenceWithRefportConnections(c.Impl as IMgaFCO, reference, WriteLine);
}
cyPhyReplaceComponent.Delete();
}
// If icon available, set it in Preferences.
// Relative paths here are from our project root.
var iconResource = ac_import.ResourceDependency.Where(x => x.Path.Contains("Icon.png")).FirstOrDefault();
//foreach (AVM.File file in ac_import.Files)
//{
// if (file.Location.Contains("Icon.png"))
// iconRelativePath = componentModelRelativePath + "/" + file.Location;
//}
if (iconResource != null)
{
var iconRelativePath = Path.Combine(compDirRelPath, iconResource.Path);
// Remove leading "\"
if (iconRelativePath.IndexOf("\\") == 0)
{
iconRelativePath = iconRelativePath.Remove(0, 1);
}
// Shrink double backslash to single
iconRelativePath = iconRelativePath.Replace("\\\\", "\\");
// Replace / with \
iconRelativePath = iconRelativePath.Replace('/', '\\');
// If icon exists, set it
if (System.IO.File.Exists(iconRelativePath))
{
// Set "icon" regnode
(c.Impl as GME.MGA.IMgaFCO).set_RegistryValue("icon", iconRelativePath);
}
}
GMEConsole.Info.WriteLine("Imported {0} to <a href=\"mga:{2}\">{1}</a>", inputFile, SecurityElement.Escape(c.Name), c.ID);
}
catch (Exception ex)
{
string error = string.Format("{0} while importing {1}: {2}", ex.GetType().Name, inputFile, ex.Message);
GMEConsole.Error.WriteLine(error);
this.Errors.Add(error);
GMEConsole.Error.WriteLine(ex.StackTrace);
}
finally
{
}
b_FirstComponent = false;
}
}
finally
{
// Reset the "enabled" state of the CLM AddOn
META.ComponentLibraryManagerAddOn.Enable(b_CLMAddOnStatus, project);
}
return(importedComponents);
}
public static Dictionary <string, CyPhy.Component> getCyPhyMLComponentDictionary_ByAVMID(CyPhy.RootFolder cyPhyMLRootFolder)
{
var rtn = new Dictionary <string, CyPhy.Component>();
var project = cyPhyMLRootFolder.Impl.Project;
MgaFilter filter = project.CreateFilter();
filter.Kind = "Component";
// The only folder that can contain components is "Components"
foreach (var componentsFolder in cyPhyMLRootFolder.Children.ComponentsCollection)
{
IMgaFolder mgaComponentsFolder = (IMgaFolder)componentsFolder.Impl;
foreach (var item in mgaComponentsFolder.GetDescendantFCOs(filter).Cast <MgaFCO>().Where(x => x.ParentFolder != null))
{
var comp = CyPhyClasses.Component.Cast(item);
rtn[comp.Attributes.AVMID] = comp;
}
}
return(rtn);
}