コード例 #1
0
        public void SingleSurfacePortCompTest()
        {
            String testName = GetCurrentMethod();

            fixture.proj.PerformInTransaction(delegate
            {
                // Open component for a single surface configured as a Port Composition
                var comp = fixture.proj.GetComponentsByName("SingleSurfacePortComp")
                           .First();
                var preconnuutP = comp.Children.PortCompositionCollection
                                  .Where(p => p.Name == "PortComposition")
                                  .First();

                // Export then Import the component
                CyPhy.Components importedcomponents;
                CyPhy.Component newcomp = ExportThenImport(comp, out importedcomponents, testName);

                // check that a connection exists
                bool collection_empty       = false;
                string collection_empty_msg = "";
                try
                {
                    Assert.NotEmpty(newcomp.Children.PortCompositionCollection);
                }
                catch (Exception ex)
                {
                    collection_empty     = true;
                    collection_empty_msg = String.Format("Port Composition collection was empty: {0}", ex.Message);
                    newcomp.Delete();
                    importedcomponents.Delete();
                }
                Assert.False(collection_empty, collection_empty_msg);
                var postconnuutP = newcomp.Children.PortCompositionCollection
                                   .First();
                // cleanup
                newcomp.Delete();
                importedcomponents.Delete();

                // check that the type is correct
                Assert.True(preconnuutP.Properties.Kind == postconnuutP.Properties.Kind, String.Format("{0} kind changed from {1} to {2}", preconnuutP.Name, preconnuutP.Properties.Kind, postconnuutP.Properties.Kind));
            });
        }
コード例 #2
0
        public void SingleSurfaceFeatureMapOppositeTest()
        {
            String testName = GetCurrentMethod();

            fixture.proj.PerformInTransaction(delegate
            {
                // Open component for a single surface configured as a Feature Map with source and destination reversed
                var comp = fixture.proj.GetComponentsByName("SingleSurfaceFeatureMapOpposite")
                           .First();
                var preconnuutF = comp.Children.FeatureMapCollection
                                  .Where(p => p.Name == "FeatureMap")
                                  .First();

                // Export then Import the component
                CyPhy.Components importedcomponents;
                CyPhy.Component newcomp = ExportThenImport(comp, out importedcomponents, testName);

                // check that a FeatureMap connection exists
                // FeatureMap connections will be changed to PortCompositions during the import, so check for PortCompositions instead
                bool collection_empty       = false;
                string collection_empty_msg = "";
                try
                {
                    Assert.NotEmpty(newcomp.Children.PortCompositionCollection);
                }
                catch (Exception ex)
                {
                    collection_empty     = true;
                    collection_empty_msg = String.Format("Post Composition (formerly Feature Map) collection was empty: {0}", ex.Message);
                    newcomp.Delete();
                    importedcomponents.Delete();
                }
                Assert.False(collection_empty, collection_empty_msg);
                var postconnuutF = newcomp.Children.PortCompositionCollection
                                   .First();
                // cleanup
                newcomp.Delete();
                importedcomponents.Delete();
                // check that the Feature Map type is now a PortComposition
                Assert.True(postconnuutF.Properties.Kind == "PortComposition", String.Format("{0} kind changed from {1} to {2}", preconnuutF.Name, preconnuutF.Properties.Kind, postconnuutF.Properties.Kind));
            });
        }
コード例 #3
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);
        }
コード例 #4
0
        public void CoordinateSystem()
        {
            String testName = GetCurrentMethod();

            fixture.proj.PerformInTransaction(delegate
            {
                var comp = fixture.proj.GetComponentsByName("CoordinateSystem")
                           .First();

                // Export then Import the component
                CyPhy.Components importedcomponents;
                CyPhy.Component newcomp = ExportThenImport(comp, out importedcomponents, testName);

                try
                {
                    CyPhy.ReferenceCoordinateSystem sysInComponent = null;
                    CyPhy.ReferenceCoordinateSystem sysInConnector = null;
                    foreach (CyPhy.PortComposition portcomp in newcomp.Children.PortCompositionCollection)
                    {
                        CyPhy.ReferenceCoordinateSystem sys = null;
                        if (portcomp.SrcEnds.ReferenceCoordinateSystem != null && portcomp.SrcEnds.ReferenceCoordinateSystem.ParentContainer.Kind == typeof(CyPhy.CADModel).Name)
                        {
                            sys = portcomp.DstEnds.ReferenceCoordinateSystem;
                        }
                        else if (portcomp.DstEnds.ReferenceCoordinateSystem != null)
                        {
                            sys = portcomp.SrcEnds.ReferenceCoordinateSystem;
                        }
                        else
                        {
                            continue;
                        }
                        if (sys.ParentContainer == newcomp)
                        {
                            if (sysInComponent != null)
                            {
                                Assert.False(true, "Found two PortCompositions connected to a ReferenceCoordinateSystem in the component. Only expected one");
                            }
                            sysInComponent = sys;
                        }
                        else if (sys.ParentContainer.Kind == typeof(CyPhy.Connector).Name)
                        {
                            if (sysInConnector != null)
                            {
                                Assert.False(true, "Found two PortCompositions connected to a ReferenceCoordinateSystem in the component's Connector. Only expected one");
                            }
                            sysInConnector = sys;
                        }
                    }
                    // TODO
                    // Assert.True(sysInComponent != null, "Did not find a connection from CADModel ReferenceCoordinateSystem to a ReferenceCoordinateSystem in the Component");
                    // Assert.True(sysInConnector != null, "Did not find a connection from CADModel ReferenceCoordinateSystem to a ReferenceCoordinateSystem in the Component's Connector");
                }
                finally
                {
                    // cleanup
                    newcomp.Delete();
                    importedcomponents.Delete();
                }
            });
        }
コード例 #5
0
        public void ModelNamesTest()
        {
            String testName = GetCurrentMethod();

            List <string> pre_namelist  = new List <string> {
            };
            List <string> post_namelist = new List <string> {
            };

            fixture.proj.PerformInTransaction(delegate
            {
                // A Component with every kind of model
                var comp = fixture.proj.GetComponentsByName("ModelNames")
                           .First();

                // gather the names of each model
                if (comp.Children.CADModelCollection.Count() > 0)
                {
                    pre_namelist.Add(comp.Children.CADModelCollection.First().Name);
                }
                if (comp.Children.ManufacturingModelCollection.Count() > 0)
                {
                    pre_namelist.Add(comp.Children.ManufacturingModelCollection.First().Name);
                }
                if (comp.Children.ModelicaModelCollection.Count() > 0)
                {
                    pre_namelist.Add(comp.Children.ModelicaModelCollection.First().Name);
                }

                // Export then Import the component
                CyPhy.Components importedcomponents;
                CyPhy.Component newcomp = ExportThenImport(comp, out importedcomponents, testName);

                // capture the names of each model returned
                if (newcomp.Children.CADModelCollection.Count() > 0)
                {
                    post_namelist.Add(newcomp.Children.CADModelCollection.First().Name);
                }
                if (newcomp.Children.ManufacturingModelCollection.Count() > 0)
                {
                    post_namelist.Add(newcomp.Children.ManufacturingModelCollection.First().Name);
                }
                if (newcomp.Children.ModelicaModelCollection.Count() > 0)
                {
                    post_namelist.Add(newcomp.Children.ModelicaModelCollection.First().Name);
                }

                // compare the lists and see what names didn't make the round trip
                string list_of_missing_names = "These names were not found ";
                bool any_missing             = false;
                foreach (string name in pre_namelist)
                {
                    if (!post_namelist.Contains(name))
                    {
                        list_of_missing_names += name;
                        list_of_missing_names += ", ";
                        any_missing            = true;
                    }
                }

                // cleanup
                newcomp.Delete();
                importedcomponents.Delete();

                // report any failures
                Assert.False(any_missing, list_of_missing_names);
            });
        }