public CADComponent(CyPhy.Component cyphycomp, string ProjectDirectory, bool size2fit = false, string format = "Creo")
{
Type = CADDataType.Component;
StructuralInterfaceNodes = new Dictionary<string, StructuralInterfaceConstraint>();
DisplayID = cyphycomp.Attributes.InstanceGUID;
Id = cyphycomp.ID;
GraphvizID = UtilityHelpers.CleanString2(cyphycomp.ID, 50, "-");
AVMID = cyphycomp.Attributes.AVMID;
RevID = "";
VersionID = cyphycomp.Attributes.Version;
CADFormat = format;
Name = cyphycomp.Name;
CadParameters = new List<CADParameter>();
ModelType = "Part";
Size2Fit = size2fit;
MaterialName = "";
CyPhyModelPath = cyphycomp.GetDirectoryPath(ProjectDirectory: ProjectDirectory);
Classification = cyphycomp.Attributes.Classifications;
HyperLink = cyphycomp.ToHyperLink();
CreateStructuralInterfaceEquivalent(cyphycomp);
AddManufacturingParameters(cyphycomp);
var specialinstr = cyphycomp.Children.ParameterCollection.Where(p => p.Name.ToUpper() == SpecialInstrParamStr);
if (specialinstr.Any())
{
SpecialInstructions = specialinstr.First().Attributes.Value.Replace("\"", "");
}
// META-3555 hack
if (cyphycomp.Children.CADModelCollection.Any())
{
foreach (var datum in cyphycomp.Children.CADModelCollection.First().Children.CADDatumCollection)
{
if (datum.Name == "FRONT" || datum.Name == "TOP" || datum.Name == "RIGHT")
{
SpecialDatums.Add(new Datum(datum, "", false));
}
}
}
foreach (var prop in cyphycomp.Children.PropertyCollection)
{
if (prop.Name.StartsWith("METADATA."))
{
MetaData.Add(prop.Name.Substring(9), prop.Attributes.Value);
}
}
}
private string GetCadModelPath(CyPhyML.Component component)
{
string modelPath = component.GetDirectoryPath();
if (modelPath == null)
{
return null;
}
else
{
foreach (var cadModel in component.Children.CADModelCollection)
{
string cadModelAbsolutePath;
if (cadModel.TryGetResourcePath(out cadModelAbsolutePath, META.ComponentLibraryManager.PathConvention.ABSOLUTE))
{
return cadModelAbsolutePath;
}
}
}
return null;
}
/// <summary>
/// Retrieves the path to the component's original ACM file, stored when it was imported.
/// Note that ANY ACM file found will be flagged as a match, even if it has been updated for some reason.
/// </summary>
/// <param name="component"></param>
/// <param name="path">The path to the ACM file, according to the PathConvention</param>
/// <param name="pathConvention"></param>
/// <param name="ProjectDirectory">Directory in which component files reside. Defaults to project directory of <paramref name="component"/></param>
/// <returns>True only if an ACM was found</returns>
public static bool TryGetOriginalACMFilePath(CyPhy.Component component, out string path, PathConvention pathConvention = PathConvention.REL_TO_COMP_DIR, string ProjectDirectory = null)
{
var componentPath = component.GetDirectoryPath(pathConvention, ProjectDirectory: ProjectDirectory);
var acmFiles = Directory.EnumerateFiles(componentPath, "*.acm", SearchOption.TopDirectoryOnly);
if (acmFiles.Any())
{
path = Path.Combine(componentPath, acmFiles.First());
return true;
}
else if (File.Exists(Path.Combine(componentPath, "ComponentData.xml")))
{
path = Path.Combine(componentPath, "ComponentData.xml");
return true;
}
path = "";
return false;
}
public static CyPhyML.Component CopyComponent(CyPhyML.Component original, bool createNewMgaComponent)
{
// This will fixup any errors/sync issues
string componentDirectory = original.GetDirectoryPath();
if (String.IsNullOrWhiteSpace(componentDirectory))
{
throw new ApplicationException(String.Format("Could not find component definition"));
}
CyPhyML.Component newComponent;
if (createNewMgaComponent)
{
if (original.ParentContainer.Impl.ObjType == GME.MGA.Meta.objtype_enum.OBJTYPE_FOLDER)
{
newComponent = CyPhyMLClasses.Component.Cast(((MgaFolder)original.ParentContainer.Impl).CopyFCODisp((MgaFCO)original.Impl));
}
else
{
newComponent = CyPhyMLClasses.Component.Cast(((MgaModel)original.ParentContainer.Impl).CopyFCODisp((MgaFCO)original.Impl, ((MgaModel)original.Impl).MetaRole));
}
string basename = newComponent.Name;
newComponent.Name = basename + "_new";
HashSet<string> childNames = new HashSet<string>();
foreach (var child in newComponent.ParentContainer.AllChildren)
{
if (child.ID != newComponent.ID)
{
childNames.Add(child.Name);
}
}
int i = 2;
while (childNames.Contains(newComponent.Name))
{
newComponent.Name = basename + "_new_" + i;
i++;
if (i > 100)
{
break;
}
}
newComponent.Attributes.AVMID = "";
newComponent.Attributes.Path = "";
// this will also assign AVMID and Path, add to project manifest, etc
string newModelpathDirectory = newComponent.GetDirectoryPath();
CopyDirectory(Path.Combine(GetProjectDir(original.Impl.Project), componentDirectory), Path.Combine(GetProjectDir(original.Impl.Project), newModelpathDirectory));
}
else
{
newComponent = original;
}
return newComponent;
}
/// <summary>
/// Given a CyPhy Component, builds a .ZIP-format Component Package, which includes
/// an ACM version, as well as all artifacts from the component's
/// backend folder. Note that it will grab ALL artifacts from that folder, not just
/// those called out as Resources by the Component. It will also exclude any
/// *.acm file found in that folder, opting to create a new ACM file from the
/// current state of the component.
/// </summary>
/// <param name="component"></param>
/// <param name="outputFolder">The folder where the component package should be created. If null, a temporary folder will be used.</param>
/// <returns>The absolute path of the component package.</returns>
public static String ExportComponentPackage(CyPhy.Component component, String outputFolder = null)
{
if (String.IsNullOrWhiteSpace(outputFolder))
{
// Assign a temp folder
outputFolder = Path.Combine(System.IO.Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(outputFolder);
}
String acmFilePath = String.Format("{0}\\{1}.component.acm", outputFolder, System.IO.Path.GetRandomFileName());
if (acmFilePath == null)
{
return null;
}
avm.Component avmComponent;
var componentBuilder = new CyPhyML2AVM.AVMComponentBuilder();
avmComponent = componentBuilder.CyPhyML2AVMNonStatic(component);
// Create a ZIP filename
String filename = String.Format("{0}.zip", component.Name);
// If not unique, try a few different ones
int counter = 1;
while (File.Exists(Path.Combine(outputFolder, filename)))
{
filename = String.Format("{0}({1}).zip", component.Name, counter++);
}
String zipFileAbsPath = Path.Combine(outputFolder, filename);
using (ZipFile zip = new ZipFile(zipFileAbsPath)
{
CompressionLevel = Ionic.Zlib.CompressionLevel.BestCompression
})
{
String compDirAbsPath = component.GetDirectoryPath(META.ComponentLibraryManager.PathConvention.ABSOLUTE);
foreach (var filePath in Directory
.EnumerateFiles(compDirAbsPath,"*.*",SearchOption.AllDirectories)
.Where(f => Path.GetExtension(f).ToLower() != ".acm"
&& Path.GetFileName(f).ToLower() != "componentdata.xml"))
{
String fileRelDir;
if (compDirAbsPath.EndsWith("/"))
{
fileRelDir = Path.GetDirectoryName(
ComponentLibraryManager.MakeRelativePath(compDirAbsPath, filePath));
}
else
{
fileRelDir = Path.GetDirectoryName(
ComponentLibraryManager.MakeRelativePath(compDirAbsPath + "/", filePath));
}
zip.AddFile(filePath, fileRelDir);
Match match = cadResourceRegex.Match(Path.Combine(fileRelDir, Path.GetFileName(filePath)));
if (match.Success)
{
Func<Resource, bool> sameFile = delegate (Resource x) {
if (x.Path == match.Groups[1].Value + match.Groups[2].Value)
return true;
Match m = cadResourceRegex.Match(x.Path);
return m.Success && m.Groups[1].Value == match.Groups[1].Value && m.Groups[2].Value == match.Groups[2].Value;
};
foreach (var resource in avmComponent.ResourceDependency.Where(sameFile))
{
Match currentMatch = cadResourceRegex.Match(resource.Path);
if (currentMatch.Success == false || (Int32.Parse(match.Groups[3].Value) > Int32.Parse(currentMatch.Groups[3].Value)))
{
resource.Path = Path.Combine(fileRelDir, Path.GetFileName(filePath));
}
}
}
}
// Add the ACM file.
SerializeAvmComponent(avmComponent, acmFilePath);
zip.AddFile(acmFilePath, "").FileName = String.Format("{0}.acm", component.Name);
zip.Save();
}
// Delete that ACM file
File.Delete(acmFilePath);
return zipFileAbsPath;
}
private void VerifyCADResources(CyPhyML.Component component, List<string> errorList)
{
string comppath = component.GetDirectoryPath(ComponentLibraryManager.PathConvention.ABSOLUTE);
foreach (var res in component.Children.ResourceCollection)
{
if (CyphyMetaLinkUtils.IsCADResource(res))
{
string fullpath = Path.Combine(comppath, res.Attributes.Path);
string[] files = Directory.GetFiles(Path.GetDirectoryName(fullpath), Path.GetFileName(fullpath) + "*");
if (files.Length == 0)
{
errorList.Add("Missing CAD resource file: " + fullpath);
}
}
}
}
public string ExportToPackage(CyPhy.ComponentAssembly ca, String s_outFolder)
{
// Create a temp folder
var pathTemp = Path.Combine(System.IO.Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(pathTemp);
// Export an ADM file to that temp folder
var pathADM = ExportToFile(ca, pathTemp);
// Generate zip file
String pathADP = Path.Combine(s_outFolder,
Path.GetFileNameWithoutExtension(pathADM) + ".adp");
File.Delete(pathADP);
using (ZipFile zip = new ZipFile(pathADP)
{
CompressionLevel = Ionic.Zlib.CompressionLevel.BestCompression
})
{
var pathCA = ca.GetDirectoryPath(ComponentLibraryManager.PathConvention.ABSOLUTE);
if (false == (pathCA.EndsWith("//") ||
pathCA.EndsWith("\\\\")))
{
pathCA += "//";
}
foreach (var file in Directory.EnumerateFiles(pathCA, "*.*", SearchOption.AllDirectories))
{
var relpath = Path.GetDirectoryName(ComponentLibraryManager.MakeRelativePath(pathCA, file));
zip.AddFile(file, relpath);
}
// Add the ADM file
zip.AddFile(pathADM, "");
zip.Save();
}
// Delete temporary directory
Directory.Delete(pathTemp, true);
return pathADP;
}
/// <summary>
/// Copy a SPICE file into a component's subdirectory.
/// </summary>
/// <param name="component">The component that is getting the SPICE file.</param>
/// <param name="path_SpiceFile">The full path to the input SPICE (".cir") file, including the file name.</param>
/// <param name="subdirectory">The subdirectory where the SPICE file will be copied, typically "Spice".</param>
/// <param name="destFileName">The name of the SPICE file after it has been uniquely copied. (See MOT-221).</param>
/// <param name="verbose">String used for exception debugging.</param>
/// <remarks>May throw an exception from the file system.</remarks>
private void CopySpiceFile(
CyPhy.Component component,
String path_SpiceFile,
string subdirectory,
out string destFileName,
out string verbose)
{
// used in creating the resource object below
string PathforComp = null;
verbose = "Begin CopySpiceFile()\n"; // Used for debugging.
// create the destination path
verbose += "step 1\n";
PathforComp = META.ComponentLibraryManager.EnsureComponentFolder(component);
verbose += "step 2\n";
PathforComp = component.GetDirectoryPath(ComponentLibraryManager.PathConvention.ABSOLUTE);
verbose += "step 3\n";
PathforComp = PathforComp.Replace('/', Path.DirectorySeparatorChar);
string finalPathName = Path.Combine(PathforComp, subdirectory);
verbose += "step 4\n";
if (Directory.Exists(finalPathName) == false)
{
Directory.CreateDirectory(finalPathName);
}
verbose += string.Format("Created directory '{0}' OK.\n", finalPathName);
destFileName = Path.GetFileName(path_SpiceFile);
// Find a file name that doesn't already exist, MOT-221.
string destinationSpiceFilePathAndName = Path.Combine(finalPathName, destFileName);
int cnt = 1;
// Make sure the named file doesn't already exist for MOT-221.
while (File.Exists(destinationSpiceFilePathAndName))
{
Logger.WriteInfo("File {0} already exists.", destinationSpiceFilePathAndName);
destFileName = Path.GetFileNameWithoutExtension(path_SpiceFile) + "_" + (cnt++) + Path.GetExtension(path_SpiceFile);
destinationSpiceFilePathAndName = Path.Combine(finalPathName, destFileName);
}
verbose += string.Format("About to copy file '{0}' to '{1}'.\n",
path_SpiceFile, destinationSpiceFilePathAndName);
System.IO.File.Copy(path_SpiceFile, destinationSpiceFilePathAndName, true);
Logger.WriteInfo("Copied file \"{0}\" to \"{1}\".", path_SpiceFile, destinationSpiceFilePathAndName);
}
