Exemplo n.º 1
0
        internal void ShowRunQueryUrl()
        {
            if (Query == null || Query.UserObject == null || Query.UserObject.Id <= 0)
            {
                MessageBoxMx.ShowError("The query must first be saved.");
                return;
            }

            string folder   = ServicesIniFile.Read("QueryLinksNetworkFolder"); // get unc form of folder
            string fileName = "Run_Query_" + Query.UserObject.Id + ".bat";     // file name
            string uncPath  = folder + '\\' + fileName;                        // unc file to write now and read later

            string       tempFile = TempFile.GetTempFileName();
            StreamWriter sw       = new StreamWriter(tempFile);
            string       cmd      =                                                            // batch command to start the Mobius client and run the specified query
                                    Lex.AddDoubleQuotes(ClientDirs.ExecutablePath) +           // path to executable in quotes
                                    " Mobius:Command='Run Query " + Query.UserObject.Id + "'"; // the mobius command to run

            sw.WriteLine(cmd);
            sw.Close();

            ServerFile.CopyToServer(tempFile, uncPath);
            FileUtil.DeleteFile(tempFile);

            string url = "file:///" + folder.Replace('\\', '/') + "/" + fileName;             // put in "file:" schema & switch slashes to get URL from UNC name

            InputBoxMx.Show(
                "The following URL can be used from a web page " +
                "to start Mobius and run the current query:",
                "Run Query URL",
                url);
            //"Mobius:Command='Run Query " + Query.UserObject.Id + "'"); // this is better but isn't accepted by SharePoint

            return;
        }
Exemplo n.º 2
0
/// <summary>
/// Write out the data and return the html/js to open the template .dxp file with the exported data file
/// </summary>
/// <param name="q"></param>
/// <param name="trvp"></param>
/// <returns></returns>

        public static string CreateSpotfireAnalysisDocument(
            Query q,
            TargetSummaryOptions trvp)
        {
            ExportParms ep = new ExportParms();

            ep.OutputDestination = OutputDest.TextFile;
            ep.ExportFileFormat  = ExportFileFormat.Csv;
            ep.OutputFileName    = TempFile.GetTempFileName(".csv");          // temp .csv file to export to
            ep.IncludeDataTypes  = true;

            string result = UalUtil.IQueryExec.RunQuery(q, ep);             // do the export

            if (result == null)
            {
                return(null);                      // just return if cancelled
            }
            string templateLibFolder =             // unc name of the lib folder (not currently used)
                                       ServicesIniFile.Read("SpotfireLibraryFolder");

            string templateLibUrl =             // url of the library containing the Mobius templates
                                    ServicesIniFile.Read("SpotfireLibraryUrl");

            templateLibUrl = @"http://[server]/SpotfireWeb/Library.aspx?folder=DCRT%20(chemistry)%20users/Mobius/Templates";

            string templateUrl = templateLibUrl + "/MultiDbView";

            string html = templateUrl;             // todo, build html/js to open the template with the specified file

            return(html);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Get security parms
        /// </summary>
        /// <returns></returns>

        public static void ReadSecurityParms()
        {
            if (_readSecurityParms)
            {
                return;
            }
            if (ServicesIniFile.IniFile == null)
            {
                return;
            }

            _useActiveDirectory                  = ServicesIniFile.ReadBool("UseActiveDirectory", true);
            _approvedMobiusUsersGroupName        = ServicesIniFile.Read("ApprovedMobiusUsers", @"<domain>Approved_Mobius_Users");
            _approvedMobiusChemViewGroupName     = ServicesIniFile.Read("ApprovedMobiusChemView", @"<domain>Approved_Mobius_Chemview");
            _approvedMobiusSequenceViewGroupName = ServicesIniFile.Read("ApprovedMobiusSequenceView", @"<domain>Lg_Mol_Search_Incl_Seq");
            string txt = ServicesIniFile.Read("SpecialMobiusSystemAccounts", "MOBIUS");

            _specialMobiusSystemAccounts = new HashSet <string>();
            string[] sa = txt.Split(',');
            foreach (string s in sa)
            {
                if (Lex.IsDefined(s))
                {
                    _specialMobiusSystemAccounts.Add(s.Trim().ToUpper());
                }
            }

            _readSecurityParms = true;
        }
Exemplo n.º 4
0
        /// <summary>
        /// Check to see if any Annotation table updates need to started
        /// </summary>

        public static string CheckForAllUsersImportFileUpdates()
        {
            if (!Security.IsMobius)
            {
                return("Only the account <mobiusAccount> can check for all annotation table updates");
            }

            UserData ud = new UserData();

            if (!ServicesIniFile.ReadBool("RunBackgroundProcessesInForeground", false))
            {
                ParameterizedThreadStart ts = new ParameterizedThreadStart(ud.CheckForImportFileUpdatesThreadMethod);
                Thread newThread            = new Thread(ts);
                newThread.IsBackground = true;
                newThread.SetApartmentState(ApartmentState.STA);
                newThread.Start(true);
            }

            else
            {
                ud.CheckForImportFileUpdatesThreadMethod(true);
            }

            return("CheckForAllUsersImportFileUpdates started");
        }
Exemplo n.º 5
0
        /// <summary>
        /// Main tool entry point
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>

        public string Run(
            string args)
        {
            QbUtil.SetMode(QueryMode.Build);             // be sure in build mode

            //List<StructureDbInfo> dbInfo = StructureDbInfo.GetList(); // get list of root structure tables
            //MetaTable mt = MetaTableCollection.Get(dbInfo[0].StructureTable); // use first structure table

            if (DatabasesToSearch.Text == "")
            {                                                  // default to first structure table
                List <RootTable> dbInfo = RootTable.GetList(); // get list of root structure tables
                if (dbInfo != null && dbInfo.Count > 0)
                {
                    DatabasesToSearch.Text = dbInfo[0].Label;
                }
            }

            if (ServicesIniFile.Read("MultStructSearchHelpUrl") != "")
            {
                Help.Enabled = true;
            }

            DialogResult dr = ShowDialog(SessionManager.ActiveForm);

            return("");
        }
Exemplo n.º 6
0
        /// <summary>
        /// Return true if this column can be a secondary image column
        /// </summary>
        /// <param name="mc"></param>
        /// <returns></returns>

        public static bool CanBeSecondaryImageColumnObsolete(
            MetaColumn mc)
        {
            if (!CanHaveRelatedImageColumn(mc))
            {
                return(false);                                            // must be image column
            }
            bool allowSecondaryImageColumns = ServicesIniFile.ReadBool("AllowSecondaryImageColumns", false);

            if (!allowSecondaryImageColumns)
            {
                return(false);
            }

            if (Lex.Contains(mc.Label, "Non Standard") ||             // nonstandards can be secondary
                Lex.Contains(mc.Label, "_NS") ||
                Lex.Contains(mc.Label, "(NS)"))
            {
                return(true);
            }

            foreach (string s in ImageResultTypes)
            {
                string resultCode = mc.Name.Substring(2);                 // get the assay metadata code

                if (s == mc.MetaTable.Code + "." + resultCode)
                {
                    return(true);
                }
            }

            return(false);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Build & return the full MetaTree
        /// </summary>
        ///
        public Dictionary <string, MetaTreeNode> GetMetaTree2()
        {
            if (ServiceFacade.UseRemoteServices)
            {
                NativeMethodTransportObject resultObject = ServiceFacade.CallServiceMethod(
                    ServiceCodes.MobiusMetaDataService,
                    MobiusMetaDataService.Build,
                    new object[] { false });

                // Get the cache from the server if newer than the client cache

                string cacheFile       = ServicesIniFile.Read("CachedTreeFile", DefaultCachedTreeFile);
                string serverCacheFile = @"<MetaDataDir>\MetaTrees\" + cacheFile;

                string clientCacheFile = ClientDirs.CacheDir + @"\" + cacheFile;
                //ServerFile.Get(serverCacheFile, clientCacheFile); // debug, always get
                bool changed = ServerFile.GetIfChanged(serverCacheFile, clientCacheFile);                 // just get if changed

                // Build the tree from the local copy of the cache

                MetaFactoryNamespace.MetaTreeFactory.BuildFromCache(ClientDirs.CacheDir, false);

                return(Mfn.MetaTreeFactory.Nodes);
            }

            else
            {
                Mfn.MetaTreeFactory.Build();
                return(Mfn.MetaTreeFactory.Nodes);
            }
        }
Exemplo n.º 8
0
        void SetupGrid(List <UserObject> alerts)
        {
            string txt, tok;

            DataTable dt = CreateDataTable();

            foreach (UserObject uo in alerts)             // fill the grid
            {
                UserObject uo2   = uo;
                Alert      alert = Alert.GetAlertFromUserObject(uo2, false);

                UserObject quo = UserObjectDao.ReadHeader(alert.QueryObjId);                 // get query header for name
                if (quo == null)
                {
                    continue;                              // associated query missing?
                }
                alert.QueryName       = quo.Name;
                alert.LastQueryUpdate = quo.UpdateDateTime;

                DataRow dr = dt.NewRow();
                SetDataRow(dr, alert);
                dt.Rows.Add(dr);
            }

            Grid.DataSource = dt;
            Grid.Refresh();

            if (ServicesIniFile.Read("AlertHelpUrl") != "")
            {
                Help.Enabled = true;
            }

            return;
        }
Exemplo n.º 9
0
        public List <StructSearchMatch> MatchList;        // merged list of matches

        /// <summary>
        /// InitializeForSession
        /// </summary>

        public static void InitializeForSession()
        {
            SearchCorpSimEnabled   = ServicesIniFile.ReadBool("CdkSimSearchCorp", true);
            SearchChemblSimEnabled = ServicesIniFile.ReadBool("CdkSimSearchChembl", true);
            UseMultipleThreads     = ServicesIniFile.ReadBool("CdkSimSearchUseMultipleThreads", true);
            Debug = ServicesIniFile.ReadBool("CdkSimSearchDebug", false);
        }
Exemplo n.º 10
0
        /// <summary>
        /// Initialize the UAL
        /// </summary>

        public static void Initialize(string iniFileName)
        {
            ServicesDirs.ExecutablePath   = Application.ExecutablePath;
            ServicesDirs.ServerStartupDir = Application.StartupPath;

            //DebugLog.Message("UalUtil.Initialize iniFileName: " + iniFileName);

            ServicesIniFile.Initialize(iniFileName);
            CommonConfigInfo.MiscConfigDir = ServicesIniFile.Read("MiscConfigDirectory");

            ServicesDirs.MetaDataDir = ServicesIniFile.Read("MetaDataDirectory");
            //DebugLog.Message("MetaDataDir: " + MetaDataDir);

            ServicesDirs.TargetMapsDir = ServicesDirs.MetaDataDir + @"\TargetMaps";             // target maps relative to MetaDataDir

            ServicesDirs.DocDir   = ServicesIniFile.Read("DocumentDirectory");
            ServicesDirs.LogDir   = ServicesIniFile.Read("LogDirectory");
            ServicesDirs.CacheDir = ServicesIniFile.Read("CacheDirectory");
            ServicesDirs.TempDir  = TempFile.TempDir = ServicesIniFile.Read("TempDirectory");
            ServicesDirs.QueryResultsDataSetDir = ServicesIniFile.Read("QueryResultsDataSetDirectory");
            ServicesDirs.BackgroundExportDir    = ServicesIniFile.Read("BackgroundExportDirectory");
            ServicesDirs.BinaryDataDir          = ServicesIniFile.Read("BinaryDataDirectory");

            ServicesDirs.ModelQueriesDir = ServicesIniFile.Read("ModelQueriesDirectory");
            ServicesDirs.ModelQueriesDir = ServicesIniFile.Read("ModelQueriesDirectory");
            ServicesDirs.ImageDir        = ServicesIniFile.Read("ImageDirectory");
            ServicesDirs.ImageDirUNC     = ServicesIniFile.Read("ImageDirectoryUNC");

            LogExecutionTimes = ServicesIniFile.ReadBool("LogUalExecutionTimes", false);

            DbCommandMx.LogDatabaseCalls = ServicesIniFile.ReadBool("LogDatabaseCalls", DbCommandMx.LogDatabaseCalls);

            return;
        }
Exemplo n.º 11
0
        private void CreateUserGroupMenuItem_Click(object sender, EventArgs e)
        {
            if (!Security.IsAdministrator(SS.I.UserName) &&
                !Security.HasPrivilege(SS.I.UserName, "CreateUserGroup") &&
                !ServicesIniFile.ReadBool("CreateUserGroupByAnyUser", true))
            {
                MessageBoxMx.ShowError("Your account is not authorized to create and/or edit user groups");
                return;
            }

            string groupName = InputBoxMx.Show("Enter the name of the new user group to be created.", "Create User Group");

            if (Lex.IsNullOrEmpty(groupName))
            {
                return;
            }

            if (UserGroups.LookupExternalName(groupName) != null)
            {
                MessageBoxMx.ShowError("Group \"" + groupName + "\" already exists");
                return;
            }

            DialogResult dr = PermissionsGroupEditor.Show(groupName, true);

            if (dr == DialogResult.OK)
            {
                PermissionsList.ItemNameComboBox.Properties.Items.Clear();                 // rebuild for new group
            }
        }
Exemplo n.º 12
0
        /// <summary>
        /// New update the list of related compounds
        /// </summary>
        /// <param name="mt"></param>
        /// <param name="cid"></param>
        /// <param name="queryStruct"></param>

        private void UpdateRelatedCidsDisplay(
            MetaTable mt,
            string cid,
            MoleculeMx queryStruct,
            int renderId)
        {
            bool useNew = ServicesIniFile.ReadBool("UseNewRelatedCompoundsPopup", true);             // use new or old related compounds display

            if (!useNew)
            {
                UpdateRelatedCidsDisplayOld(mt, cid, queryStruct);
                return;
            }

            //if (!SS.I.AllowGroupingBySalts || // need this?
            //	Lex.Ne(MetaTable.DefaultRootTable, mt.Name))
            //{
            //	this.Height = RelatedStructuresPanel.Top;
            //	return;
            //}

            if (SS.I.FindRelatedCpdsInQuickSearch)
            {
                RSM.StartSearchAndRetrievalOfRelatedStructures(mt.Name, cid, queryStruct, RelatedStructureBrowser.StructureSearchTypes);
            }

            return;
        }
Exemplo n.º 13
0
        /// <summary>
        /// Initialize the UAL and load the MetaData
        /// </summary>

        //public void Initialize()
        //{
        //  InitializeUAL();
        //  LoadMetaData();
        //  return;
        //}

        /// <summary>
        /// Initialize the UAL so basic Oracle operations can be performed
        /// </summary>

        public void InitializeUAL()
        {
            lock (_lockObject)
            {
                // Set the ini file

                if (ServicesIniFile.IniFile == null)
                {
                    string iniFilePath = GetMobiusServicesIniFileLocation();
                    Mobius.UAL.UalUtil.Initialize(iniFilePath);
                    if (!System.IO.File.Exists(iniFilePath))
                    {
                        throw new Exception("IniFile doesn't exist: " + iniFilePath);
                    }
                }

                if (ServicesDirs.MetaDataDir == "")
                {
                    ServicesDirs.MetaDataDir = ServicesIniFile.Read("MetaData");
                }

                string logFile = ServicesDirs.LogDir + @"\" + Mobius.ComOps.CommonConfigInfo.ServicesLogFileName; // log file name
                Mobius.Services.Util.ServicesLog.Initialize(logFile);                                             // initialize for logging

                // Get list of valid privileges

                Mobius.ComOps.PrivilegesMx.SetValidPrivilegeListFromInifile(ServicesIniFile.IniFile);

                // Load data source meta info

                if (Mobius.UAL.DataSourceMx.DataSources == null ||
                    Mobius.UAL.DataSourceMx.DataSources.Count == 0 ||
                    Mobius.UAL.DataSourceMx.Schemas == null ||
                    Mobius.UAL.DataSourceMx.Schemas.Count == 0)
                {
                    Mobius.UAL.DataSourceMx.LoadMetadata();
                }

                // Foundation dependency injections

                // Dependency injections for client components
                //Mobius.Data.Query.IDataTableManager = new DataTableManager();
                //Mobius.Data.ChemicalStructure.IChemicalStructureUtil = new Mobius.ClientComponents.ChemicalStructureUtil();
                //Mobius.Data.RootTable.IServerFile = new ServerFile();
                //Mobius.ServServiceFacade.ServiceFacade.IDebugLog = new DebugLogMediator();

                Mobius.Data.ResultsViewProps.ResultsViewFactory = new Mobius.ClientComponents.ViewFactory();
                Mobius.Data.Query.IDataTableManager             = new Mobius.ClientComponents.DataTableManager();
                Mobius.Data.CidList.ICidListDao        = new Mobius.UAL.CidListDao();
                Mobius.Data.MoleculeMx.IMoleculeMxUtil = new Mobius.QueryEngineLibrary.MoleculeUtil();
                Mobius.Data.RootTable.IServerFile      = new Mobius.UAL.ServerFile();

                Mobius.Data.InterfaceRefs.IUserObjectDao  = new Mobius.UAL.IUserObjectDaoMethods();
                Mobius.Data.InterfaceRefs.IUserObjectIUD  = new Mobius.ClientComponents.IUserObjectIUDMethods();
                Mobius.Data.InterfaceRefs.IUserObjectTree = new Mobius.ClientComponents.IUserObjectTreeMethods();

                Mobius.MolLib1.StructureConverter.ICdkUtil = new Mobius.CdkMx.CdkUtil();
            }
        }
Exemplo n.º 14
0
        /// <summary>
        /// GetDefaultWebPlayerUrl
        /// </summary>
        /// <returns></returns>

        static string GetDefaultWebPlayerUrl()
        {
            if (_defaultWebplayerUrl == null)
            {
                _defaultWebplayerUrl = ServicesIniFile.Read("SpotfireWebplayer", "https://[server]/spotfire/wp");
            }

            return(_defaultWebplayerUrl);
        }
Exemplo n.º 15
0
/// <summary>
/// Get server file name to export to
/// </summary>
/// <param name="rf"></param>
/// <param name="objId"></param>
/// <returns></returns>

        static string GetServerFileName(ResultsFormat rf, int objId)
        {
            string clientFile   = rf.OutputFileName;           // file name on client
            string ext          = Path.GetExtension(clientFile);
            string serverExpDir = ServicesIniFile.Read("BackgroundExportDirectory");
            string serverFile   = serverExpDir + @"\" + objId + ext;           // use background export userobject id & client file extension

            return(serverFile);
        }
Exemplo n.º 16
0
        /// <summary>
        /// Do initial read of the list of views and the users for each view.
        /// </summary>
        public static void ReadViews()
        {
            StreamReader sr;

            ViewDict = new Dictionary <string, RestrictedDatabaseView>();

            bool restrictionsActive = ServicesIniFile.ReadBool("UseRestrictedDatabaseViews", false);

            if (!restrictionsActive)
            {
                return;
            }

            string dirName = ServicesDirs.MetaDataDir + @"\RestrictedDatabaseViews";

            if (!Directory.Exists(dirName))
            {
                return;                                         // throw new Exception("RestrictedDatabaseViews Directory does not exist: " + dirName);
            }
            string fileName = dirName + @"\ViewList.txt";

            if (!File.Exists(fileName))
            {
                return;
            }
            try
            {
                sr = new StreamReader(fileName);
            }
            catch (Exception ex)
            { return; }

            while (true)
            {
                string txt = sr.ReadLine();
                if (txt == null)
                {
                    break;
                }
                if (Lex.IsUndefined(txt) || txt.StartsWith(";"))
                {
                    continue;
                }

                string viewName = txt.Trim().ToUpper();

                RestrictedDatabaseView v = new RestrictedDatabaseView();
                ViewDict[viewName] = v;
                v.Name             = viewName;
                ReadViewUsers(v);
            }

            sr.Close();
        }
Exemplo n.º 17
0
        /// <summary>
        /// Send mail object
        /// </summary>
        /// <param name="mail"></param>

        public static void SendEmail(
            MailMessage mail)
        {
            SmtpClient mailClient     = new SmtpClient();
            string     mailServerName = ServicesIniFile.Read("SmtpServer");

            mailClient.Host = mailServerName;
            mailClient.UseDefaultCredentials = true;
            //						mailClient.DeliveryMethod = SmtpDeliveryMethod.PickupDirectoryFromIis;
            mailClient.Send(mail);
        }
Exemplo n.º 18
0
        /// <summary>
        /// Main tool entry point
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>

        public string Run(
            string args)
        {
            QbUtil.SetMode(QueryMode.Build);             // be sure in build mode

            if (ServicesIniFile.Read("RgroupDecompositionHelpUrl") != "")
            {
                Help.Enabled = true;
            }

            this.ShowDialog();
            return("");
        }
Exemplo n.º 19
0
        /// <summary>
        /// Show NCBI Entre Gene web page for supplied geneId and/or symbol
        /// </summary>
        /// <param name="geneIdSymbol"></param>

        public static string GetTargetDescriptionUrl(
            string targetIdSymbol)
        {
            int    targetId;
            string targetSymbol;

            if (String.IsNullOrEmpty(targetIdSymbol))
            {
                return(null);
            }

            else if (Lex.IsInteger(targetIdSymbol))             // numeric gene id
            {
                targetId = int.Parse(targetIdSymbol);
            }

            else if (targetIdSymbol.Contains("-"))             // 1234-Symbol form
            {
                string[] sa = targetIdSymbol.Split('-');
                targetSymbol = sa[1].ToUpper();
                try { targetId = TargetSymbolToId(targetSymbol); }
                catch { return(null); }
            }

            else             // must be symbol
            {
                targetSymbol = targetIdSymbol.ToUpper();
                try { targetId = TargetSymbolToId(targetSymbol); }
                catch { return(null); }
            }

            if (targetId <= 0)
            {
                return(null);
            }

            string url = ServicesIniFile.Read("NcbiGeneIdUrlTemplate");

            if (String.IsNullOrEmpty(url))
            {
                return(null);
            }
            url = url.Replace("<GENE_ID>", targetId.ToString());
            return(url);
        }
Exemplo n.º 20
0
        /// <summary>
        /// Display any new news if requested
        /// </summary>

        public static bool ShowNewNews()
        {
            try
            {
                string lastNews = Preferences.Get("ShowNews");
                if (lastNews == "false")
                {
                    return(false);                                     // user doesn't want to see news
                }
                if (ClientState.IsDeveloper)
                {
                    return(false);                                         // debug
                }
                string fileName = ServicesIniFile.Read("NewsFile");
                if (fileName == "")
                {
                    throw new Exception("NewsFile not defined");
                }
                DateTime dt = File.GetLastWriteTime(fileName);

                string fileDate = String.Format("{0,4:0000}{1,2:00}{2,2:00}", dt.Year, dt.Month, dt.Day);

                if (String.Compare(fileDate, lastNews) > 0 || lastNews == "")
                {
                    ShowNews();                     // show the news
                    UserObjectDao.SetUserParameter(SS.I.UserName, "ShowNews", fileDate);
                    return(true);
                }

                else
                {
                    return(false);
                }
            }

            catch (Exception ex)
            {
                //if (ClientState.IsDeveloper)
                // MessageBoxMx.ShowError(ex.Message);
                return(false);
            }
        }
Exemplo n.º 21
0
        /// <summary>
        /// Check to see if any imports need to started
        /// </summary>

        public static string CheckForCurrentUserImportFileUpdates()
        {
            UserData ud = new UserData();

            if (!ServicesIniFile.ReadBool("RunBackgroundProcessesInForeground", false))             // run as separate thread?
            {
                ParameterizedThreadStart ts = new ParameterizedThreadStart(ud.CheckForImportFileUpdatesThreadMethod);
                Thread newThread            = new Thread(ts);
                newThread.IsBackground = true;
                newThread.SetApartmentState(ApartmentState.STA);
                newThread.Start(false);
            }

            else
            {
                ud.CheckForImportFileUpdatesThreadMethod(false);
            }

            return("CheckForImportFileUpdates started");
        }
Exemplo n.º 22
0
        /// <summary>
        /// Some methods in the AlertQueue class are static.  Therefore the _alertQueueFileName will not be set in those cases.
        /// This method will ensure we have a valid file name in all cases.
        /// </summary>
        /// <returns></returns>
        private static string GetAlertQueueFileName()
        {
            if (_alertQueueFileName != null)
            {
                return(_alertQueueFileName);
            }

            if (_serverLogDir == null)
            {
                _serverLogDir = ServicesIniFile.Read("LogDirectory");
            }
            if (String.IsNullOrEmpty(_serverLogDir))
            {
                throw new Exception("Server LogDirectory not defined in config file");
            }

            if (_alertQueueFileName == null)
            {
                _alertQueueFileName = _serverLogDir + @"\AlertQueue.txt";
            }
            return(_alertQueueFileName);
        }
Exemplo n.º 23
0
        public static void Initialize()
        {
            MetaTableXmlFolder = ServicesDirs.MetaDataDir + @"\MetaTables";
            string rootFile = ServicesIniFile.Read("MetaTableRootFile", "Metatables.xml");             // root to start at

            if (rootFile.IndexOf(@"\") < 0)
            {
                rootFile = MetaTableXmlFolder + @"\" + rootFile;
            }

            IncludeQualifiedNumberDetailColumnsInMetaTables =             // get flag for including hidden Qualified Number detail cols in metatables
                                                              ServicesIniFile.ReadBool("IncludeQualifiedNumberDetailColumnsInMetaTables", true);

            BuildFromXmlFile(rootFile);             // get initial metatables

            RegisterFactory("CalcField", new CalcFieldMetaFactory());
            RegisterFactory("Annotation", new AnnotationMetaFactory());
            RegisterFactory("MultiTable", new MultiTableMetaFactory());
            RegisterFactory("Oracle", new OracleMetaFactory());
            RegisterFactory("PubChem", new PubChemMetaFactory());
            RegisterFactory("UnpivotedAssay", new UnpivotedAssayMetaFactory());
            RegisterFactory("SpotfireLink", new SpotfireLinkMetafactory());
        }
Exemplo n.º 24
0
        /// <summary>
        /// Read and set the config settings
        /// </summary>

        public static void ReadConfigSettings()
        {
            if (ConfigSettingsHaveBeenRead)
            {
                return;
            }

            SearchFssEnabled       = ServicesIniFile.ReadBool("RssSearchFss", true);
            SearchCorpDbFssEnabled = ServicesIniFile.ReadBool("RssSearchCorpFss", true);
            SearchChemblFssEnabled = ServicesIniFile.ReadBool("RssSearchChemblFss", true);

            SearchMmpEnabled                   = ServicesIniFile.ReadBool("RssSearchMmp", true);
            SearchCorpDbMmpEnabled             = ServicesIniFile.ReadBool("RssSearchCorpMmp", true);
            SearchChemblMmpEnabled             = ServicesIniFile.ReadBool("RssSearchChemblMmp", false);
            KeepHighestCidPairScoreOnlyEnabled = ServicesIniFile.ReadBool("RssKeepHighestCidPairScoreOnly", true);

            SearchSmallWorldEnabled       = ServicesIniFile.ReadBool("RssSearchSmallWorld", true);
            SearchCorpDbSmallWorldEnabled = ServicesIniFile.ReadBool("RssSearchCorpSmallWorld", true);
            SearchChemblSmallWorldEnabled = ServicesIniFile.ReadBool("RssSearchChemblSmallWorld", true);

            //SearchSmallWorldEnabled = SearchCorpSmallWorldEnabled = SearchChemblSmallWorldEnabled = true; // for testing

            SearchSimEnabled       = ServicesIniFile.ReadBool("RssSearchSim", true);
            SearchCorpSimEnabled   = ServicesIniFile.ReadBool("RssSearchCorpSim", true);
            SearchChemblSimEnabled = ServicesIniFile.ReadBool("RssSearchChemblSim", true);

            SearchSssEnabled       = ServicesIniFile.ReadBool("RssSearchSSS", true);
            SearchCorpSssEnabled   = ServicesIniFile.ReadBool("RssSearchCorpSSS", true);
            SearchChemblSssEnabled = ServicesIniFile.ReadBool("RssSearchChemblSSS", true);

            UseMultipleThreads = ServicesIniFile.ReadBool("RssUseMultipleThreads", true);
            UseCachedResults   = ServicesIniFile.ReadBool("RssUseCachedResults", true);
            Debug = ServicesIniFile.ReadBool("RssDebug", false);

            ConfigSettingsHaveBeenRead = true;
            return;
        }
Exemplo n.º 25
0
        /// <summary>
        /// Display the news file
        /// </summary>

        public static void ShowNews()
        {
            try
            {
                string fileName = ServicesIniFile.Read("NewsFile");
                if (fileName == "")
                {
                    return;
                }

                if (Instance == null)
                {
                    Instance = new NewsDialog();
                }

                Instance.ShowNewsCheckBox.Checked = Preferences.GetBool("ShowNews");
                Instance.Show();
                Application.DoEvents();                 // allow form to draw before doing navigate
                Instance.WebBrowser.Navigate(fileName);
            }


            catch (Exception ex) { return; }
        }
Exemplo n.º 26
0
        /// <summary>
        ///  Create WinForms.ChromiumWebBrowser and navigate to the initial page
        /// </summary>

        public void LoadInitialPage()
        {
            if (Browser != null)
            {
                return;
            }

            string url = "";

            if (RendererMode == KekuleJsControlMode.OffScreenBitmap)
            {
                url = ServicesIniFile.ReadWithException("KekuleJsRendererUrl");
            }

            else if (RendererMode == KekuleJsControlMode.BrowserViewOnly)
            {
                url = ServicesIniFile.ReadWithException("KekuleJsRendererUrl");
            }

            else if (RendererMode == KekuleJsControlMode.BrowserEditor)
            {
                url = ServicesIniFile.ReadWithException("KekuleJsEditorUrl");
            }

            if (Debug)
            {
                DebugLog.Message("Loading initial " + RendererMode + " mode page: " + url + IdText);
            }

            Browser = new WebBrowser();             // create the browser

            Browser.Location = new Point(0, 0);
            Browser.Size     = new Size(256, 256);

            Browser.Dock                   = DockStyle.None;
            Browser.Anchor                 = (AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Bottom | AnchorStyles.Right);
            Browser.Name                   = "WebBrowser";
            Browser.ScrollBarsEnabled      = false;
            Browser.ScriptErrorsSuppressed = JavaScriptManager.SuppressJavaScriptErrors;
            Browser.ObjectForScripting     = new JavaScriptManager(this);         // create ScriptManager that can call back to this JavaScriptInterface instance from within web page JavaScript

            // The following three events are also in WebBrowserWrapper (not needed here)
            Browser.DocumentCompleted += new WebBrowserDocumentCompletedEventHandler(Browser_DocumentCompleted);
            Browser.Navigated         += new WebBrowserNavigatedEventHandler(this.WebBrowser_Navigated);
            Browser.Navigating        += new WebBrowserNavigatingEventHandler(this.WebBrowser_Navigating);

            Browser.ProgressChanged   += new WebBrowserProgressChangedEventHandler(Browser_ProgressChanged);
            Browser.StatusTextChanged += new EventHandler(WebBrowserStatusTextChanged);
            Browser.Resize            += new EventHandler(WebBrowser_Resize);
            Browser.SizeChanged       += new EventHandler(Browser_SizeChanged);

            if (ContainingControl != null)
            {
                Browser.Size = ContainingControl.Size;
                ContainingControl.Controls.Clear();
                ContainingControl.Controls.Add(Browser);
            }
            else
            {
                Browser.Size = new Size(1024, 768);
            }

            BrowserWrapper = new WebBrowserWrapper(Browser);
            BrowserWrapper.NavigateAndWait(url);             // navigate to the initial page

            ResizeRendering();

            if (Debug)
            {
                DebugLog.Message("Browser created, initial page loaded" + IdText);
            }

            return;
        }
Exemplo n.º 27
0
        /// <summary>
        /// Edit a new or existing calculated field
        /// </summary>
        /// <param name="cf"></param>
        /// <param name="uoIn"></param>
        /// <returns></returns>

        public static UserObject Edit(
            CalcField cf,
            UserObject uoIn)
        {
            QueryTable qt;
            MetaTable  mt = null;
            MetaColumn mc, field;
            UserObject uo2;
            CalcField  cf2 = null;
            string     msg;
            int        i1;

            CalcFieldEditor lastInstance = Instance;

            CalcFieldEditor i = Instance = new CalcFieldEditor();

            i.AdvancedPanel.BorderStyle = BorderStyle.None;
            i.AdvancedPanel.Visible     = false;
            i.AdvancedPanel.Dock        = DockStyle.Fill;

            i.BasicPanel.BorderStyle = BorderStyle.None;
            i.BasicPanel.Visible     = true;
            i.BasicPanel.Dock        = DockStyle.Fill;
            i.SetupStandardCalculatedFields();
            if (ServicesIniFile.Read("CalcFieldHelpUrl") != "")
            {
                i.Help.Enabled = true;
            }

            if (lastInstance != null)
            {
                i.StartPosition = FormStartPosition.Manual;
                i.Location      = lastInstance.Location;
                i.Size          = lastInstance.Size;
                lastInstance    = null;
            }

            if (uoIn == null)
            {
                uoIn = new UserObject(UserObjectType.CalcField);
            }

            else if (uoIn.Id > 0)             // get existing metatable for calc field for exclusion in BuildQuickSelectTableMenu
            {
                string tName = "CALCFIELD_" + uoIn.Id.ToString();
                mt = MetaTableCollection.GetExisting(tName);
                if (MainMenuControl != null)
                {
                    MainMenuControl.UpdateMruList(tName);
                }
            }

            Instance.UoIn = uoIn;

            string title = "Edit Calculated Field";

            if (!String.IsNullOrEmpty(uoIn.Name))
            {
                title += " - " + uoIn.Name;
            }
            Instance.Text = title;

            Instance.CalcField = cf;          // what we're editing
            Instance.SetupForm();             // set up the form

            DialogResult dr = Instance.ShowDialog(SessionManager.ActiveForm);

            if (dr == DialogResult.Cancel)
            {
                return(null);
            }

            return(Instance.UoIn);            // return saved object
        }
Exemplo n.º 28
0
        public bool CanCreateTempTables = false;                            // true if the associated account can create temp tables

        /// <summary>
        /// Load metadata describing connections and associated schemas
        /// </summary>
        /// <param name="dsFileName"></param>
        /// <returns></returns>

        public static int LoadMetadata()
        {
            XmlAttributeCollection atts;

            // Get some inifile parameters first

            if (ServicesIniFile.IniFile == null)
            {
                throw new Exception("ServicesIniFile.IniFile is null");
            }

            SessionConnection.Pooling            = ServicesIniFile.ReadBool("Pooling", true);
            SessionConnection.MinPoolSize        = ServicesIniFile.ReadInt("MinPoolSize", 1);
            SessionConnection.IncrPoolSize       = ServicesIniFile.ReadInt("IncrPoolSize", 5);
            SessionConnection.MaxPoolSize        = ServicesIniFile.ReadInt("MaxPoolSize", 100);
            SessionConnection.DecrPoolSize       = ServicesIniFile.ReadInt("DecrPoolSize", 1);
            SessionConnection.ConnectionLifetime = ServicesIniFile.ReadInt("ConnectionLifetime", 0);

            string tok     = ServicesIniFile.Read("KeyListPredType", "Parameterized");
            int    enumInt = EnumUtil.Parse(typeof(KeyListPredTypeEnum), tok);

            if (enumInt >= 0)
            {
                DbCommandMx.DefaultKeyListPredType = (KeyListPredTypeEnum)enumInt;
            }

            DbCommandMx.DbFetchRowCount = ServicesIniFile.ReadInt("DbFetchRowCount", DbCommandMx.DbFetchRowCount);
            DbCommandMx.DbFetchSizeMax  = ServicesIniFile.ReadInt("DbFetchSizeMax", DbCommandMx.DbFetchSizeMax);

            DataSources = new Dictionary <string, DataSourceMx>(StringComparer.OrdinalIgnoreCase);
            Schemas     = new Dictionary <string, DbSchemaMx>(StringComparer.OrdinalIgnoreCase);

            string dsFileName = ServicesDirs.MetaDataDir + @"\" + "DataSources.xml";

            StreamReader sr  = new StreamReader(dsFileName);
            XmlDocument  doc = new XmlDocument();

            doc.Load(sr);
            XmlNode node = doc.FirstChild;

            while (node != null)
            {
                if (node.NodeType == XmlNodeType.Element)
                {
                    break;
                }
                node = node.NextSibling;
                if (node == null)
                {
                    throw new Exception("No initial element found");
                }
            }

            if (!Lex.Eq(node.Name, "DataSources"))
            {
                throw new Exception("Expected DataSources node: " + node.Name);
            }

            atts = node.Attributes;             // datasources attributes
            for (int i = 0; i < atts.Count; i++)
            {
                XmlNode att = atts.Item(i);

                if (Lex.Eq(att.Name, "DblinkConnName"))
                {
                }                                                           // obsolete key word

                else
                {
                    throw new Exception
                              ("Unexpected DataSources attribute: " + att.Name);
                }
            }

            node = node.FirstChild;
            while (node != null)
            {
                if (node.NodeType != XmlNodeType.Element)
                {
                    ;                                                       // ignore non-elements
                }
                else if (Lex.Eq(node.Name, "DataSource") ||                 // connection element
                         Lex.Eq(node.Name, "Connection"))
                {
                    DataSourceMx cd = new DataSourceMx();

                    atts = node.Attributes;
                    for (int i = 0; i < atts.Count; i++)
                    {
                        XmlNode att = atts.Item(i);

                        if (Lex.Eq(att.Name, "DatabaseType") || Lex.Eq(att.Name, "DbType"))
                        {
                            if (!Enum.TryParse <DatabaseType>(att.Value, true, out cd.DbType))
                            {
                                throw new Exception("Invalid Database type: " + att.Value);
                            }
                        }

                        else if (Lex.Eq(att.Name, "Name"))
                        {
                            cd.DataSourceName = att.Value.ToUpper().Trim();
                        }

                        else if (Lex.Eq(att.Name, "DatabaseName") || Lex.Eq(att.Name, "OracleName"))
                        {
                            cd.DatabaseLocator = att.Value.ToUpper().Trim();
                        }

                        else if (Lex.Eq(att.Name, "ConnectionString"))                         // keep case if connection string
                        {
                            cd.DatabaseLocator = att.Value.Trim();
                        }

                        else if (Lex.Eq(att.Name, "UserName"))
                        {
                            cd.UserName = att.Value.Trim();                             // keep case as is (Oracle 11g)
                        }
                        else if (Lex.Eq(att.Name, "Password"))
                        {
                            cd.Password = att.Value.Trim();                           // keep case as is (Oracle 11g)
                        }
                        else if (Lex.Eq(att.Name, "MdlInit"))                         // mdl initialization
                        {
                            cd.InitCommand = "select cdcaux.ctenvinit('" + att.Value.Trim() + "') from dual";
                        }

                        else if (Lex.Eq(att.Name, "InitCommand"))
                        {
                            cd.InitCommand = att.Value.Trim();
                        }

                        else if (Lex.Eq(att.Name, "KeyDataSource"))
                        {
                            bool.TryParse(att.Value.Trim(), out cd.IsKeyDataSource);
                        }

                        else if (Lex.Eq(att.Name, "CanCreateTempTables"))
                        {
                            bool.TryParse(att.Value.Trim(), out cd.CanCreateTempTables);
                        }

                        else if (Lex.Eq(att.Name, "AlwaysUseDbLink"))
                        {
                        }                                                                         // obsolete

                        else
                        {
                            throw new Exception
                                      ("Unexpected Connection attribute: " + att.Name);
                        }
                    }

                    if (cd.DataSourceName == "")
                    {
                        DebugLog.Message("Connection is missing name: " + cd.DatabaseLocator);
                    }
                    else if (DataSourceMx.DataSources.ContainsKey(cd.DataSourceName))
                    {
                        DebugLog.Message("Data source defined twice: " + cd.DataSourceName);
                    }
                    else
                    {
                        DataSourceMx.DataSources.Add(cd.DataSourceName, cd);
                    }
                }

                else if (Lex.Eq(node.Name, "SchemaToDataSource") ||                 // schema map element
                         Lex.Eq(node.Name, "SchemaToConnection"))
                {
                    DbSchemaMx schema = new DbSchemaMx();
                    atts = node.Attributes;
                    for (int i = 0; i < atts.Count; i++)
                    {
                        XmlNode att = atts.Item(i);

                        if (Lex.Eq(att.Name, "Schema"))
                        {
                            schema.Name = att.Value.ToUpper().Trim();
                        }

                        else if (Lex.Eq(att.Name, "AliasFor"))
                        {
                            schema.AliasFor = att.Value.ToUpper().Trim();
                        }

                        else if (Lex.Eq(att.Name, "Connection"))
                        {
                            schema.DataSourceName = att.Value.ToUpper().Trim();
                        }

                        else if (Lex.Eq(att.Name, "Label") || Lex.Eq(att.Name, "L"))
                        {
                            schema.Label = att.Value.Trim();
                        }

                        else
                        {
                            throw new Exception
                                      ("Unexpected Connection attribute: " + att.Name);
                        }
                    }

                    if (schema.Name == "")
                    {
                        throw new Exception("Missing schema name");
                    }
                    if (schema.DataSourceName == "")
                    {
                        throw new Exception("Missing data source/connection name");
                    }
                    Schemas[schema.Name] = schema;
                }

                else
                {
                    throw new Exception("Expected Connection or SchemaToDataSource element but saw " +
                                        node.Name);
                }

                node = node.NextSibling;
            }
            sr.Close();

            return(DataSources.Count);
        }
Exemplo n.º 29
0
/// <summary>
/// Method to run query in background and save the results for later retrieval
/// </summary>
/// <param name="q"></param>
/// <param name="emailSubject">Send email if defined</param>
/// <param name="templateName"></param>
/// <returns></returns>

        public static string RunBackgroundQuery(
            Query q,
            string emailSubject,
            string templateName)
        {
            ResultsFormat    rf;
            QueryManager     qm;
            DataTableManager dtm;
            string           msg = "", html = "", resultsFileName;
            string           viewCmd = "View Background Query Results";

            bool notifyUserByEmail = !Lex.IsNullOrEmpty(emailSubject);

            try                                       // execute the query & read in all results
            {
                QbUtil.AddQueryAndRender(q, false);   // add it to the query builder
                q.BrowseSavedResultsUponOpen = false; // be sure query is run rather than using existing results

                msg = QueryExec.RunQuery(q, OutputDest.WinForms);

                qm  = q.QueryManager as QueryManager;
                dtm = qm.DataTableManager;
                DialogResult dr = dtm.CompleteRetrieval();
            }
            catch (Exception ex)              // some exceptions are normal, e.g. no criteria, others may be bugs
            {
                msg = "RunQueryInBackground could not complete due to an unexpected exception: " + DebugLog.FormatExceptionMessage(ex);
                ServicesLog.Message(msg);
                if (notifyUserByEmail)
                {
                    Email.Send(null, SS.I.UserInfo.EmailAddress, emailSubject, msg);
                }

                return(msg);
            }

            if (dtm.KeyCount == 0)
            {
                msg = "Query " + Lex.Dq(q.UserObject.Name) + " returned no results.";
                if (notifyUserByEmail)
                {
                    Email.Send(null, SS.I.UserInfo.EmailAddress, emailSubject, msg);
                }
                return(msg);
            }

            try
            {
                resultsFileName = q.ResultsDataTableFileName;                 // see if name supplied in query
                if (Lex.IsNullOrEmpty(resultsFileName))
                {
                    resultsFileName = "Query_" + q.UserObject.Id + "_Results.bin";
                }
                resultsFileName = ServicesIniFile.Read("BackgroundExportDirectory") + @"\" + resultsFileName;
                dtm.WriteBinaryResultsFile(resultsFileName);                 // write the file
                UserObject cidListUo = SaveBackgroundQueryResultsReferenceObject(qm, "BkgrndQry", resultsFileName);

                if (!Lex.IsNullOrEmpty(templateName))
                {
                    html = ReadTemplateFile(templateName);
                }

                if (notifyUserByEmail)
                {
                    AlertUtil.MailResultsAvailableMessage(                     // send the mail
                        q,
                        dtm.KeyCount,
                        SS.I.UserInfo.EmailAddress,
                        emailSubject,
                        viewCmd,
                        cidListUo.Id,
                        null,
                        html);
                }

                else
                {
                    html = SubstituteBackgroundExportParameters(html, "", "", dtm.RowCount, dtm.KeyCount, false, "");
                    return(html);                    // return the html
                }
            }
            catch (Exception ex)
            {
                msg = "Error sending background query results: " + DebugLog.FormatExceptionMessage(ex);
                ServicesLog.Message(msg);
            }

            return(msg);
        }
Exemplo n.º 30
0
/// <summary>
/// Get image & coordinates file from KEGG FTP
/// </summary>
/// <param name="pathwayId"></param>
/// <returns></returns>

        public static TargetMap GetKeggPathway(
            string pathwayId)
        {
            String ftpPath, rec;

            if (TargetMapDict == null)
            {
                ReadTargetMapDict();
            }

            TargetMap tm = new TargetMap();

            tm.Name   = pathwayId;
            tm.Label  = pathwayId;            // default label
            tm.Source = "KEGG";
            tm.Type   = "Pathway";

// Build basic paths

            string ftpFolder = ServicesIniFile.Read("KeggPathWayFtpDirectory");             // get from here

            if (String.IsNullOrEmpty(ftpFolder))
            {
                throw new Exception("KeggPathWayFtpDirectory not defined");
            }
            if (!ftpFolder.EndsWith(@"/"))
            {
                ftpFolder += @"/";
            }

// Get map_title file and read title for pathway

            string filePath      = TargetMapDir + @"\map_title.tab";
            string pathwayPrefix = pathwayId.Substring(0, 3);
            string pathwayNbr    = pathwayId.Substring(3);          //
            bool   download      = false;

            if (!File.Exists(filePath))
            {
                download = true;
            }

            while (true)
            {
                if (download)
                {
                    ftpPath = ftpFolder + "map_title.tab";
                    Download(ftpPath, filePath);
                }

                StreamReader sr = new StreamReader(filePath);
                while (true)
                {
                    rec = sr.ReadLine();
                    if (rec == null)
                    {
                        break;
                    }
                    if (!rec.StartsWith(pathwayNbr))
                    {
                        continue;
                    }
                    string[] sa = rec.Split('\t');
                    tm.Label = sa[1].Trim() + " (KEGG: " + pathwayId + ")";
                    break;
                }
                sr.Close();

                if (!String.IsNullOrEmpty(tm.Label))
                {
                    break;                         // have it
                }
                else if (download)                 // already downloaded but not found
                {
                    tm.Label = pathwayId;
                    break;
                }

                else
                {                 // download again if not done yet
                    download = true;
                    continue;
                }
            }

// Get gif file

            if (Lex.Ne(pathwayPrefix, "map"))             // if not a base level map then in organisms
            {
                ftpFolder += @"organisms/";
            }
            ftpFolder += pathwayPrefix + @"/";

            ftpPath  = ftpFolder + pathwayId + ".gif";
            filePath = TargetMapDir + @"\" + pathwayId + ".gif";
            Download(ftpPath, filePath);

            Image img = Image.FromFile(filePath);

            tm.Bounds     = new Rectangle(0, 0, img.Width, img.Height);
            tm.MarkBounds = true;

            filePath = TargetMapDir + @"\" + pathwayId + ".png";             // save as .png file that Spotfire can read
            img.Save(filePath, System.Drawing.Imaging.ImageFormat.Png);
            tm.ImageType = "png";
            tm.ImageFile = Path.GetFileName(filePath);             // store just file name

// Get coordinates file

            if (Lex.Eq(pathwayPrefix, "map"))
            {
                ftpPath  = ftpFolder + pathwayId + "_ec.coord";
                filePath = TargetMapDir + @"\" + pathwayId + "_ec.coord";
            }
            else
            {
                ftpPath  = ftpFolder + pathwayId + "_gene.coord";
                filePath = TargetMapDir + @"\" + pathwayId + "_gene.coord";
            }
            Download(ftpPath, filePath);
            tm.CoordsFile = Path.GetFileName(filePath);

            TargetMapDict[tm.Name.ToUpper()]         = tm;     // add to list of maps
            TargetMapDictByLabel[tm.Label.ToUpper()] = tm;

            GetMapWithCoords(pathwayId);             // read in coords to validate file format

// Write out the map file containing basic map data

            filePath = TargetMapDir + @"\" + pathwayId + ".map";
            StreamWriter sw = new StreamWriter(filePath);

            rec =
                tm.Name + "\t" +
                tm.Label + "\t" +
                tm.Source + "\t" +
                tm.Type + "\t" +
                tm.ImageType + "\t" +
                tm.ImageFile + "\t" +
                tm.Bounds.Left + "\t" +
                tm.Bounds.Top + "\t" +
                tm.Bounds.Right + "\t" +
                tm.Bounds.Bottom + "\t" +
                tm.MarkBounds + "\t" +
                tm.CoordsFile;

            sw.WriteLine(rec);
            sw.Close();

            return(tm);
        }