Beispiel #1
0
        /// <summary>
        /// Quick reject based on IFC file info and existence of Revit file.
        /// </summary>
        /// <param name="doc">The parent document.</param>
        /// <param name="originalIFCFileName">The IFC file name.</param>
        /// <returns>True if we need a reload; false if nothing has changed.</returns>
        private bool NeedsReload(Document doc, string originalIFCFileName)
        {
            string ifcFileName = ImporterIFCUtils.GetLocalFileName(doc, originalIFCFileName);

            if (ifcFileName == null)
            {
                return(true);
            }

            string revitFileName = IFCImportFile.GetRevitFileName(ifcFileName);

            // If the RVT file doesn't exist, we'll reload.  Otherwise, look at saved file size and timestamp.
            if (!File.Exists(revitFileName))
            {
                return(true);
            }

            FileInfo infoIFC = null;

            try
            {
                infoIFC = new FileInfo(ifcFileName);
            }
            catch
            {
                return(true);
            }

            long ifcFileLength = infoIFC.Length;

            if ((TheOptions.OriginalFileSize != 0) && (ifcFileLength != TheOptions.OriginalFileSize))
            {
                return(true);
            }

            // If we got a local IFC file name that is different from the original file name, that may have resulted in a load
            // operation that would update the timestamp.  In this case, ignore that check.
            // Unfortunately, this means that it is possible that an updated IFC file with the same file size but different contents
            // would register as unchanged when it was.  The alternative, though, is to reload the IFC file on every file open,
            // which is unacceptable.
            bool checkFileTimestamp = (ifcFileName == originalIFCFileName);

            if (checkFileTimestamp)
            {
                // Ignore ticks - only needs to be accurate to the second, or 10,000,000 ticks.
                Int64 diffTicks = infoIFC.LastWriteTimeUtc.Ticks - TheOptions.OriginalTimeStamp.Ticks;
                if (diffTicks < 0 || diffTicks >= 10000000)
                {
                    return(true);
                }
            }

            return(false);
        }
Beispiel #2
0
        /// <summary>
        /// The main entry point into the .NET IFC import code
        /// </summary>
        /// <param name="importer">The internal ImporterIFC class that contains information necessary for the import process.</param>
        public void ImportIFC(ImporterIFC importer)
        {
            TheImporter = this;

            IDictionary <String, String> options = importer.GetOptions();

            TheOptions = m_ImportOptions = IFCImportOptions.Create(options);

            // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it.
            try
            {
                string fullFileName = importer.FullFileName;

                string revitFileName = IFCImportFile.GetRevitFileName(fullFileName);
                if (!TheOptions.ForceImport && !NeedsReload(fullFileName, revitFileName))
                {
                    return;
                }

                // Clear the category mapping table, to force reload of options.
                IFCCategoryUtil.Clear();

                if (TheOptions.Intent != IFCImportIntent.Reference)
                {
                    IFCImportFile.Import(importer);
                }
                else
                {
                    ReferenceIFC(importer.Document, fullFileName, options);
                }
            }
            catch (Exception ex)
            {
                if (Importer.TheLog != null)
                {
                    Importer.TheLog.LogError(-1, ex.Message, false);
                }
            }
            finally
            {
                if (Importer.TheLog != null)
                {
                    Importer.TheLog.Close();
                }
                if (IFCImportFile.TheFile != null)
                {
                    IFCImportFile.TheFile.Close();
                }
            }
        }
Beispiel #3
0
        /// <summary>
        /// Import an IFC file into a given document for Reference only.
        /// </summary>
        /// <param name="document">The host document for the import.</param>
        /// <param name="origFullFileName">The full file name of the document.</param>
        /// <param name="options">The list of configurable options for this import.</param>
        public void ReferenceIFC(Document document, string origFullFileName, IDictionary <String, String> options)
        {
            // We need to generate a local file name for all of the intermediate files (the log file, the cache file, and the shared parameters file).
            string localFileName = ImporterIFCUtils.GetLocalFileName(document, origFullFileName);

            if (localFileName == null)
            {
                throw new InvalidOperationException("Could not generate local file name for: " + origFullFileName);
            }

            // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it.
            // It is possible that the log file may have been created in CreateImporter above,
            // if it is used by an external developer.
            if (TheLog == null)
            {
                m_ImportLog = IFCImportLog.CreateLog(localFileName, "log.html", !m_ImportOptions.DisableLogging);
            }

            Document originalDocument = document;
            Document ifcDocument      = null;

            if (TheOptions.Action == IFCImportAction.Link)
            {
                string linkedFileName = IFCImportFile.GetRevitFileName(localFileName);

                ifcDocument = LoadOrCreateLinkDocument(originalDocument, linkedFileName);
            }
            else
            {
                ifcDocument = originalDocument;
            }

            bool useCachedRevitFile = DocumentUpToDate(ifcDocument, localFileName);

            // In the case where the document is already opened as a link, but it has been updated on disk,
            // give the user a warning and use the cached value.
            if (!useCachedRevitFile && ifcDocument.IsLinked)
            {
                useCachedRevitFile = true;
                Importer.AddDelayedLinkError(BuiltInFailures.ImportFailures.IFCCantUpdateLinkedFile);
            }

            if (!useCachedRevitFile)
            {
                m_ImportCache = IFCImportCache.Create(ifcDocument, localFileName);

                // Limit creating the cache to Link, but may either remove limiting or make it more restrict (reload only) later.
                if (TheOptions.Action == IFCImportAction.Link)
                {
                    TheCache.CreateExistingElementMaps(ifcDocument);
                }

                // TheFile will contain the same value as the return value for this function.
                IFCImportFile.Create(localFileName, m_ImportOptions, ifcDocument);
            }

            if (useCachedRevitFile || IFCImportFile.TheFile != null)
            {
                IFCImportFile theFile = IFCImportFile.TheFile;
                if (theFile != null)
                {
                    if (theFile.IFCProject != null)
                    {
                        IFCObjectDefinition.CreateElement(ifcDocument, theFile.IFCProject);
                    }

                    // Also process any other entities to create.
                    foreach (IFCObjectDefinition objDef in IFCImportFile.TheFile.OtherEntitiesToCreate)
                    {
                        IFCObjectDefinition.CreateElement(ifcDocument, objDef);
                    }

                    theFile.EndImport(ifcDocument, localFileName);
                }

                if (TheOptions.Action == IFCImportAction.Link)
                {
                    // If we have an original Revit link file name, don't create a new RevitLinkType -
                    // we will use the existing one.
                    bool      useExistingType = (TheOptions.RevitLinkFileName != null);
                    ElementId revitLinkTypeId = IFCImportFile.LinkInFile(origFullFileName, localFileName, ifcDocument, originalDocument, useExistingType, !useCachedRevitFile);
                }
            }

            if (m_ImportCache != null)
            {
                m_ImportCache.Reset(ifcDocument);
            }
        }
Beispiel #4
0
        /// <summary>
        /// Import an IFC file into a given document for Reference only.
        /// </summary>
        /// <param name="document">The host document for the import.</param>
        /// <param name="fullFileName">The full file name of the document.</param>
        /// <param name="options">The list of configurable options for this import.</param>
        public void ReferenceIFC(Document document, string fullFileName, IDictionary <String, String> options)
        {
            // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it.
            m_ImportLog = IFCImportLog.CreateLog(fullFileName, "log.html");

            Document originalDocument = document;
            Document ifcDocument      = null;

            if (TheOptions.Action == IFCImportAction.Link)
            {
                string linkedFileName = IFCImportFile.GetRevitFileName(fullFileName);

                ifcDocument = LoadOrCreateLinkDocument(originalDocument, linkedFileName);
                if (ifcDocument == null)
                {
                    return;
                }
            }
            else
            {
                ifcDocument = originalDocument;
            }

            bool useCachedRevitFile = DocumentUpToDate(ifcDocument, fullFileName);

            // In the case where the document is already opened as a link, but it has been updated on disk,
            // give the user a warning and use the cached value.
            if (!useCachedRevitFile && ifcDocument.IsLinked)
            {
                useCachedRevitFile = true;
                Importer.AddDelayedLinkError(BuiltInFailures.ImportFailures.IFCCantUpdateLinkedFile);
            }

            if (!useCachedRevitFile)
            {
                m_ImportCache = IFCImportCache.Create(ifcDocument, fullFileName);

                // Limit creating the cache to Link, but may either remove limiting or make it more restrict (reload only) later.
                if (TheOptions.Action == IFCImportAction.Link)
                {
                    TheCache.CreateExistingElementMaps(ifcDocument);
                }

                // TheFile will contain the same value as the return value for this function.
                IFCImportFile.Create(fullFileName, m_ImportOptions, ifcDocument);
            }

            if (useCachedRevitFile || IFCImportFile.TheFile != null)
            {
                IFCImportFile theFile = IFCImportFile.TheFile;
                if (theFile != null)
                {
                    if (theFile.IFCProject != null)
                    {
                        IFCObjectDefinition.CreateElement(ifcDocument, theFile.IFCProject);
                    }

                    // Also process any other entities to create.
                    foreach (IFCObjectDefinition objDef in IFCImportFile.TheFile.OtherEntitiesToCreate)
                    {
                        IFCObjectDefinition.CreateElement(ifcDocument, objDef);
                    }

                    theFile.EndImport(ifcDocument, fullFileName);
                }

                if (TheOptions.Action == IFCImportAction.Link)
                {
                    // If we have an original Revit link file name, don't create a new RevitLinkType -
                    // we will use the existing one.
                    bool      useExistingType = (TheOptions.RevitLinkFileName != null);
                    ElementId revitLinkTypeId = IFCImportFile.LinkInFile(fullFileName, ifcDocument, originalDocument, useExistingType, !useCachedRevitFile);
                }
            }

            if (m_ImportCache != null)
            {
                m_ImportCache.Reset(ifcDocument);
            }
        }
Beispiel #5
0
        public void ImportIFC(ImporterIFC importer)
        {
            TheImporter = this;

            IDictionary <String, String> options = importer.GetOptions();

            TheOptions = m_ImportOptions = IFCImportOptions.Create(options);

            // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it.
            try
            {
                string revitFileName = IFCImportFile.GetRevitFileName(importer.FullFileName);
                if (!TheOptions.ForceImport && !NeedsReload(importer.FullFileName, revitFileName))
                {
                    return;
                }

                // Clear the category mapping table, to force reload of options.
                IFCCategoryUtil.Clear();

                if (TheOptions.Intent != IFCImportIntent.Reference)
                {
                    IFCImportFile.Import(importer);
                }
                else
                {
                    Document originalDocument = importer.Document;
                    Document ifcDocument      = null;

                    if (TheOptions.Action == IFCImportAction.Link)
                    {
                        string linkedFileName = IFCImportFile.GetRevitFileName(importer.FullFileName);

                        ifcDocument = LoadOrCreateLinkDocument(originalDocument, linkedFileName);
                        if (ifcDocument == null)
                        {
                            return;
                        }
                    }
                    else
                    {
                        ifcDocument = originalDocument;
                    }

                    bool useCachedRevitFile = DocumentUpToDate(ifcDocument, importer.FullFileName);

                    // In the case where the document is already opened as a link, but it has been updated on disk,
                    // give the user a warning and use the cached value.
                    if (!useCachedRevitFile && ifcDocument.IsLinked)
                    {
                        useCachedRevitFile = true;
                        Importer.AddDelayedLinkError(BuiltInFailures.ImportFailures.IFCCantUpdateLinkedFile);
                    }

                    if (!useCachedRevitFile)
                    {
                        m_ImportCache = IFCImportCache.Create(ifcDocument, importer.FullFileName);

                        // Limit creating the cache to Link, but may either remove limiting or make it more restrict (reload only) later.
                        if (TheOptions.Action == IFCImportAction.Link)
                        {
                            TheCache.CreateExistingElementMaps(ifcDocument);
                        }

                        // TheFile will contain the same value as the return value for this function.
                        IFCImportFile.Create(importer.FullFileName, m_ImportOptions, ifcDocument);
                    }

                    if (useCachedRevitFile || IFCImportFile.TheFile != null)
                    {
                        if (IFCImportFile.TheFile != null)
                        {
                            if (IFCImportFile.TheFile.IFCProject != null)
                            {
                                IFCObjectDefinition.CreateElement(ifcDocument, IFCImportFile.TheFile.IFCProject);
                            }
                            IFCImportFile.TheFile.EndImport(ifcDocument, importer.FullFileName);
                        }

                        if (TheOptions.Action == IFCImportAction.Link)
                        {
                            // If we have an original Revit link file name, don't create a new RvtLinkSymbol -
                            // we will use the existing one.
                            bool useExistingType = (TheOptions.RevitLinkFileName != null);
                            IFCImportFile.LinkInFile(importer.FullFileName, ifcDocument, originalDocument, useExistingType, !useCachedRevitFile);
                        }
                    }

                    m_ImportCache.Reset(ifcDocument);
                }
            }
            catch (Exception ex)
            {
                if (IFCImportFile.TheFile != null)
                {
                    IFCImportFile.TheFile.Log.LogError(-1, ex.Message, false);
                }
            }
            finally
            {
                if (IFCImportFile.TheFile != null)
                {
                    IFCImportFile.TheFile.Close();
                }
            }
        }