/*-----------------------------------------------------------------------------*/
        /// <summary>
        /// open a connection to a model does not have to be the active model
        /// </summary>
        /// <param name="oModel">the model that is being used as repository</param>
        /// <param name="ecSession">the session</param>
        /// <returns></returns>
/*-----------------------------------------------------------------------------*/
        public static ECSR.RepositoryConnection OpenConnectionToModel(
            BCOM.ModelReference oModel, ECSS.ECSession ecSession)
        {
            ECSR.RepositoryConnectionService repositoryConnectionService;
            repositoryConnectionService = ECSR.RepositoryConnectionServiceFactory.GetService();

            string fileName  = oModel.DesignFile.FullName; // implies active file
            string modelName = oModel.Name;                // implies active model
            string location;

            location = BECP.Common.ECRepositoryConnectionHelper.BuildLocation(
                fileName, modelName);

            string ecPluginId = BDGNP.Constants.PluginID;

#if DEBUG
            System.Diagnostics.Debug.WriteLine("location = " + location);
            System.Diagnostics.Debug.WriteLine("PluginID = " + ecPluginId);
#endif
            ECSR.RepositoryConnection connection;
            connection = repositoryConnectionService.Open(ecSession, ecPluginId,
                                                          location, null, null);
            System.Diagnostics.Debug.Assert(null != connection);

            string fsrPlugin = BFSRP.FSRClientHelper.FSRPluginId;

            return(connection);
        }
示例#2
0
        /// <summary> Open a connection to a repository </summary>
        internal ECSR.RepositoryConnection OpenConnection()
        {
            ECSS.ECSession ecSession = ECSS.SessionManager.CreateSession(); // the ECSession provides context for most ECService calls.

            ECSR.RepositoryConnection connection = OpenConnectionToActiveModel(ecSession);

            return(connection);
        }
示例#3
0
        /// <summary>Gets a connection to the active DGN Model</summary>
        public static ECSR.RepositoryConnection OpenConnectionToActiveModel(ECSS.ECSession ecSession)
        {
            ECSR.RepositoryConnectionService repositoryConnectionService = ECSR.RepositoryConnectionServiceFactory.GetService();

            string fileName  = ""; // implies active file
            string modelName = ""; // implies active model
            //string loc;
            string location = BECPC.ECRepositoryConnectionHelper.BuildLocation(fileName, modelName);

            string ecPluginId = BDGNP.Constants.PluginID;

            Debug.WriteLine("location = " + location);
            Debug.WriteLine("PluginID = " + ecPluginId);

            //WS: this is actually checking schemas with instances, if schema is deleted, but instances still exist, it will get error.
            ECSR.RepositoryConnection connection = repositoryConnectionService.Open(ecSession, ecPluginId, location, null, null);

            Debug.Assert(null != connection);

            return(connection);
        }
/*-----------------------------------------------------------------------------*/
        /// <summary>
        /// The command to process the active file.  It will attempt to create a session
        /// and open the connection to the active model.
        /// If the connection cannot be opened it will error out.
        /// The findEmbeded method to look at the file for embedded schemas
        /// </summary>
        /// <param name="unparsed">not used.</param>
/*-----------------------------------------------------------------------------*/
        public static void BVSchemaCheckerCommand(System.String unparsed)
        {
            string        errMessage = "ERROR";
            List <string> schemaList = new List <string>();

            //set to silent mode
            m_silentMode = false;
            if (1 == BVSchemaChecker.mdlSystem_startedAsAutomationServer() && ((null != unparsed) && unparsed == "FROM_HOOK"))
            {
                return;
            }
            //if an unparsed string is sent in then set silent to true
            if (1 != BVSchemaChecker.mdlSystem_startedAsAutomationServer() && ((null != unparsed) && (unparsed.Length > 0)))
            {
                m_silentMode = true;
            }
            //see if it is an imodel if so then don't check.
            if (1 == BVSchemaChecker.IsIModel(BVSchemaChecker.ComApp.ActiveModelReference.MdlModelRefP()))
            {
                BVSchemaChecker.ComApp.MessageCenter.AddMessage("this is an i-model", "i-models are not processed", BCOM.MsdMessageCenterPriority.Info, false);
                return;
            }
            //if there are references then we process special.
            if (BVSchemaChecker.ComApp.ActiveModelReference.Attachments.Count > 0)
            {//if the references are imodels then notify the users.
                if (BVSchemaChecker.HasIModelReference(BVSchemaChecker.ComApp.ActiveModelReference))
                {
                    BVSchemaChecker.ComApp.MessageCenter.AddMessage("Has IModel Attached",
                                                                    "This file has an imodel in the attachment set",
                                                                    BCOM.MsdMessageCenterPriority.Info, false);
                }

                BCOM.DesignFile workFile = BVSchemaChecker.ComApp.OpenDesignFileForProgram(
                    BVSchemaChecker.ComApp.ActiveDesignFile.FullName, true);
                //create a model in the file that has no references
                //proces the new model.  this will avoid using the references as part
                //of the ec repository.
                //delete the model after the processing.
                try
                {
                    BCOM.ModelReference workModel = workFile.Models.Add(
                        workFile.DefaultModelReference,
                        "working", "working",
                        BCOM.MsdModelType.Normal, true);

                    int iAttachmentCount = workModel.Attachments.Count;
                    for (int i = iAttachmentCount; i > 0; --i)
                    {
                        BCOM.Attachment oAtt = workModel.Attachments[i];
                        workModel.Attachments.Remove(oAtt);
                    }

                    BVSchemaChecker.ProcessModel(workModel);
                    workFile.Models.Delete(workModel);
                }
                catch (Exception e)
                {
                    Console.WriteLine("unable to wrtie to file");
                }
                workFile.Close();
                return;
            }

            //if I am a simple file with normal dgn references
            ECSR.RepositoryConnection connection = null;
            CSVReporter.CreateReport(string.Format("SC_{0}.csv", DateTime.Now.ToString("yyyy-dd-MM")));
            if (m_debugMode)
            {
                BVSchemaChecker.ComApp.MessageCenter.AddMessage("created csv file",
                                                                string.Format("created report file at {0}", CSVReporter.FileName),
                                                                BCOM.MsdMessageCenterPriority.Info, m_debugMode);
            }

            if (m_usesSelector)
            {
                m_selectorForm.SetMessage("Processing File " + BVSchemaChecker.ComApp.ActiveDesignFile.Name);
            }

            try
            {
                ECSS.ECSession ecSession = ECSS.SessionManager.CreateSession(true);
                connection = BVSchemaChecker.OpenConnectionToActiveModel(ecSession);

                if (BVSchemaChecker.FindEmbededSchemas(connection, schemaList))
                {
                    BVSchemaChecker.ComApp.MessageCenter.AddMessage("Found schema in this file. \n Please contact the Bentley Execution team with the Schema list provided on the following dialog box. \n Select Ok to get a list of the schema you will need to provide",
                                                                    "Found Schema",
                                                                    BCOM.MsdMessageCenterPriority.Error,
                                                                    m_silentMode);
                    BVSchemaChecker.iSchemaFoundCount++;
                    //show the list...
                    if (m_silentMode)
                    {
                        SchemaListForm sform = new SchemaListForm();
                        sform.SetSchemaNames(schemaList);
                        sform.ShowDialog();
                    }
                }
                else
                {
                    BVSchemaChecker.ComApp.MessageCenter.AddMessage("no schema in the file",
                                                                    "nothing found",
                                                                    BCOM.MsdMessageCenterPriority.Info,
                                                                    (unparsed != "FROM_HOOK"));
                }
            }
            catch (Exception e)
            {
                BVSchemaChecker.ComApp.MessageCenter.AddMessage(e.Message, e.Message,
                                                                BCOM.MsdMessageCenterPriority.Error,
                                                                !BVSchemaChecker.bUseLogFile);
                errMessage = e.Message;
            }
            finally
            {
                if (null == connection)
                {
                    CSVReporter.writeLine(BVSchemaChecker.strCurrentProjectName,
                                          BVSchemaChecker.ComApp.ActiveDesignFile.Name,
                                          BVSchemaChecker.ComApp.ActiveModelReference.Name,
                                          errMessage, false);
                }
                else
                {
                    BVSchemaChecker.CloseConnection(connection);
                }

                CSVReporter.close();
            }
        }
/*-----------------------------------------------------------------------------*/
        /// <summary>
        /// processes a dgn model to see if it has embedded schema
        /// </summary>
        /// <param name="oModel">the model to check</param>
        /// <returns>true that the model was processed and does not have a schema.</returns>
/*-----------------------------------------------------------------------------*/
        public static bool ProcessModel(BCOM.ModelReference oModel)
        {
            List <string> schemaList   = new List <string>();
            bool          m_debugMode  = false;
            bool          m_silentMode = false;
            string        errMessage   = "ERROR";
            bool          bStatus      = true;

            ECSR.RepositoryConnection connection = null;
            CSVReporter.CreateReport(string.Format("SC_{0}.csv", DateTime.Now.ToString("yyyy-dd-MM")));
            if (m_debugMode)
            {
                BVSchemaChecker.ComApp.MessageCenter.AddMessage("created csv file",
                                                                string.Format("created report file at {0}", CSVReporter.FileName),
                                                                BCOM.MsdMessageCenterPriority.Info, m_debugMode);
            }
            try
            {
                ECSS.ECSession ecSession = ECSS.SessionManager.CreateSession(true);
                connection = BVSchemaChecker.OpenConnectionToModel(oModel, ecSession);

                if (BVSchemaChecker.FindEmbededSchemas(connection, schemaList))
                {
                    BVSchemaChecker.ComApp.MessageCenter.AddMessage("found schema in the file",
                                                                    "found Schema",
                                                                    BCOM.MsdMessageCenterPriority.Error,
                                                                    m_silentMode);
                    BVSchemaChecker.iSchemaFoundCount++;
                    SchemaListForm sform = new SchemaListForm();
                    sform.SetSchemaNames(schemaList);
                    sform.ShowDialog();
                    bStatus = false;
                }
                else
                {
                    BVSchemaChecker.ComApp.MessageCenter.AddMessage("no schema in the file",
                                                                    "nothing found",
                                                                    BCOM.MsdMessageCenterPriority.Info,
                                                                    m_silentMode);
                }
            }
            catch (Exception e)
            {
                BVSchemaChecker.ComApp.MessageCenter.AddMessage(e.Message, e.Message,
                                                                BCOM.MsdMessageCenterPriority.Error,
                                                                !BVSchemaChecker.bUseLogFile);
                errMessage = e.Message;
                bStatus    = false;
            }
            finally
            {
                if (null == connection)
                {
                    CSVReporter.writeLine(BVSchemaChecker.strCurrentProjectName,
                                          BVSchemaChecker.ComApp.ActiveDesignFile.Name,
                                          BVSchemaChecker.ComApp.ActiveModelReference.Name,
                                          errMessage, false);
                }
                else
                {
                    BVSchemaChecker.CloseConnection(connection);
                }

                CSVReporter.close();
            }
            return(bStatus);
        }