Beispiel #1
0
        /// <summary>
        /// Let the user select an existing annotation and edit it
        /// </summary>
        /// <returns></returns>

        public static MetaTable OpenExistingAnnotationTable(
            UserObject uo)
        {
            if (uo == null)             // prompt if not supplied
            {
                uo = UserObjectOpenDialog.ShowDialog(UserObjectType.Annotation, "Open Annotation");
            }
            if (uo == null)
            {
                return(null);
            }

            if (!Permissions.UserHasWriteAccess(SS.I.UserName, uo))
            {
                MessageBoxMx.ShowError("You are not authorized to edit this annotation table.");
                return(null);
            }

            UserDataEditor editor = new UserDataEditor();
            UserObject     uo2    = editor.Edit(uo);

            if (uo2 == null)
            {
                return(null);
            }

            string    tName = "ANNOTATION_" + uo.Id.ToString();
            MetaTable mt    = MetaTableCollection.Get(tName);          // return new version of metatable

            return(mt);
        }
Beispiel #2
0
        private void DeleteDatabase_Click(object sender, EventArgs e)
        {
            DataRow      dr;
            UcdbDatabase ucdb;
            int          ri;

            ri = GridView.FocusedRowHandle;
            if (ri < 0)
            {
                MessageBoxMx.ShowError("You must select the user compound database first");
                return;
            }

            dr   = DataTable.Rows[ri];
            ucdb = (UcdbDatabase)dr["Ucdb"];

            DialogResult dR = MessageBoxMx.Show("Are you sure you want to delete user compound database: \"" +
                                                ucdb.Name + "\"?", UmlautMobius.String, MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

            if (dR != DialogResult.Yes)
            {
                return;
            }

            ucdb.RowState = UcdbRowState.Deleted;  // mark for deletion
            Udbs.UpdateDatabase(ucdb);             // mark data for deletion

            DataTable.Rows.RemoveAt(ri);
            RenumberRows();
        }
Beispiel #3
0
/// <summary>
/// If SavedListUo is defined just return otherwise check in default folder for ListName
/// </summary>

        string ResolveSavedListUo()
        {
            if (SavedListUo != null)
            {
                return("CNLIST_" + SavedListUo.Id);
            }
            if (ListName.Text == "")
            {
                return("");
            }

            UserObject uo = new UserObject(UserObjectType.CnList, SS.I.UserName, ListName.Text);

            UserObjectTree.AssignDefaultObjectFolder(uo, UserObjectType.CnList);
            SavedListUo = UserObjectDao.ReadHeader(uo);
            if (SavedListUo != null)
            {
                return("CNLIST_" + SavedListUo.Id);
            }

            string errMsg = "List " + ListName.Text + " does not exist";

            MessageBoxMx.Show(errMsg, UmlautMobius.String, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            return(null);            // return null if nonexistant list
        }
Beispiel #4
0
/// <summary>
/// See if valid advanced calculated field
/// </summary>
/// <returns></returns>

        private bool IsValidAdvancedCalcField()
        {
            List <MetaColumn> mcList;

            string advExpr;

            if (Lex.IsNullOrEmpty(AdvancedExpr.Text))
            {
                MessageBoxMx.Show(
                    "The calculated field expression is blank", UmlautMobius.String);
                return(false);
            }

            try { advExpr = ParseAdvancedExpr(AdvancedExpr.Text, out mcList); }
            catch (Exception ex)
            {
                MessageBoxMx.Show(ex.Message, UmlautMobius.String);
                return(false);
            }

            string errmsg = QueryEngine.ValidateCalculatedFieldExpression(advExpr);

            if (!Lex.IsNullOrEmpty(errmsg))
            {
                MessageBoxMx.Show(
                    "Invalid calculated field expression:\r\n\r\n" + errmsg, UmlautMobius.String);
                return(false);
            }

            return(true);
        }
Beispiel #5
0
        private void NumericIntervalDialog_OK_Click(object sender, EventArgs e)
        {
            Decimal intervalSize;

            if (!Decimal.TryParse(IntervalSize.Text, out intervalSize) || intervalSize <= 0)
            {
                MessageBoxMx.ShowError("The interval size must be a positive number");
                IntervalSize.Focus();
                return;
            }

// Update the aggregation def

            AggregationDef ad = AggregationDef;

            if (!ad.IsGroupingType)
            {
                ad.Role = AggregationRole.RowGrouping;
            }

            ad.GroupingType = GroupingTypeEnum.NumericInterval;
            AggregationDef.NumericIntervalSize = intervalSize;
            DialogResult = DialogResult.OK;
            return;

            //UpdateGrid();
            //Hide();
        }
Beispiel #6
0
        /// <summary>
        /// Run query using supplied OutputDest displaying any error message
        /// </summary>
        /// <param name="query"></param>
        /// <param name="outputDest"></param>
        /// <returns></returns>

        public static string RunQuery(
            Query query,
            OutputDest outputDest)
        {
            try
            {
                bool browseExistingResults = QbUtil.BrowseExistingDataTable(query);
                return(RunQuery(query, outputDest, OutputFormContext.Session, null, browseExistingResults));
            }

            catch (UserQueryException ex)
            {             // just show message
                Progress.Hide();
                MessageBoxMx.ShowError(ex.Message);
                return("");
            }

            catch (Exception ex)
            {             // non-standard query exception, provide more detail
                Progress.Hide();
                string msg = DebugLog.FormatExceptionMessage(ex);

                if (!Lex.Contains(msg, "QueryLogged:"))                 // exception & query
                {
                    QueryEngine.LogExceptionAndSerializedQuery(msg, query);
                }
                else
                {
                    ServicesLog.Message(msg);                  // just log exception
                }
                MessageBoxMx.ShowError("Unexpected Exception\n\n" + msg);
                return("");
            }
        }
Beispiel #7
0
        bool Save(bool prompt)
        {
            UserObject uo2;

            if (!IsValidCalcField())
            {
                return(false);
            }
            if (!GetCalcFieldForm())
            {
                return(false);
            }
            if (prompt)
            {
                uo2 = UserObjectSaveDialog.Show("Save Calculated Field Definition", UoIn);
                if (uo2 == null)
                {
                    return(false);
                }
            }
            else
            {
                uo2 = UoIn.Clone();
            }

            if (!UserObjectUtil.UserHasWriteAccess(uo2))
            {             // is the user authorized to save this?
                MessageBoxMx.ShowError("You are not authorized to save this calculated field");
                return(false);
            }

            SessionManager.DisplayStatusMessage("Saving calculated field...");

            string content = CalcField.Serialize();

            uo2.Content = content;

            //need the name of the folder to which the object will be saved
            MetaTreeNode targetFolder = UserObjectTree.GetValidUserObjectTypeFolder(uo2);

            if (targetFolder == null)
            {
                MessageBoxMx.ShowError("Failed to save your calculated field.");
                return(false);
            }

            UserObjectDao.Write(uo2);

            string tName = "CALCFIELD_" + uo2.Id.ToString();

            QbUtil.UpdateMetaTableCollection(tName);
            MainMenuControl.UpdateMruList(tName);

            string title = "Edit Calculated Field - " + uo2.Name;

            Text = title;
            UoIn = uo2.Clone();             // now becomes input object
            SessionManager.DisplayStatusMessage("");
            return(true);
        }
Beispiel #8
0
        /// <summary>
        /// See if saving this query would have an acceptable effect
        /// on any persisted alert results.
        /// </summary>
        /// <param name="q"></param>
        /// <returns>True if ok to save</returns>

        public static bool QuerySaveOkForAlertResults(
            Query q)
        {
            Alert alert = GetAlertByQueryId(q.UserObject.Id);

            if (alert == null)
            {
                return(true);                                  // no alert so ok
            }
            if (alert.LastCheck != DateTime.MinValue &&        // has alert been checked?
                q.AlertQueryState != GetAlertQueryCriteria(q)) // have criteria changed?
            {
                DialogResult dr = MessageBoxMx.Show(
                    "Since the search criteria for this new-data alerting query have changed the \n" +
                    "alert state will be \"reset\" which means that the next time the alert runs it will\n" +
                    "not mail out any detected data changes but will simply record the current state of\n" +
                    "the data with respect to the new search criteria. Subsequent alert runs will then\n" +
                    "check for new data changes.\n\n" +
                    "Do you still want to continue to save the query?",
                    UmlautMobius.String, MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
                if (dr != DialogResult.Yes)
                {
                    return(false);
                }

                alert.LastCheck   = DateTime.MinValue;    // reset the alert
                alert.LastResults = null;                 // (should already be null)
                alert.Write();
            }

            return(true);
        }
Beispiel #9
0
        public bool ValidateData()
        {
            bool dayChecked =
                checkBoxSunday.Checked ||
                checkBoxMonday.Checked ||
                checkBoxTuesday.Checked ||
                checkBoxWednesday.Checked ||
                checkBoxThursday.Checked ||
                checkBoxFriday.Checked ||
                checkBoxSaturday.Checked;

            if (!dayChecked)
            {
                MessageBoxMx.Show("You must select a day of the week.");
                return(false);
            }

            if (textEditNumWeeks.EditValue == null || int.Parse(textEditNumWeeks.EditValue.ToString()) < 1)
            {
                MessageBoxMx.Show("You must enter the weekly interval.");
                return(false);
            }

            return(true);
        }
Beispiel #10
0
        private void DeleteFavoriteMenuItem_Click(object sender, EventArgs e)
        {
            SessionManager.LogCommandUsage("ContentsFavoritesDelete");

            MetaTreeNode node = QbContentsTree.CurrentContentsMetaTreeNode;

            if (node == null)
            {
                return;
            }
            if (String.IsNullOrEmpty(node.Target))
            {
                return;
            }

            DialogResult dr = MessageBoxMx.Show(
                "Are you sure you want to delete: '" + node.Label + "' ?",
                "Confirm Delete", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

            if (dr != DialogResult.Yes)
            {
                return;
            }

            SessionManager.Instance.MainMenuControl.DeleteFavorite(node);
        }
Beispiel #11
0
        /// <summary>
        /// Return true if query is ok for alert or there is no alert associated with query
        /// </summary>
        /// <param name="q"></param>
        /// <returns></returns>

        public static bool QueryValidForAlert(Query q)
        {
            int criteriaCount = q.GetCriteriaCount(true, false);             // count simple criteria

            if (q.LogicType == QueryLogicType.Complex && !String.IsNullOrEmpty(q.ComplexCriteria))
            {
                criteriaCount = 1;
            }

            if (criteriaCount == 0)
            {
                MessageBoxMx.Show(
                    "An alert cannot be defined on this query because it does not contain any search criteria.\n" +
                    "You may want to use the \"Where data exists\" criteria on one of the fields in the query.",
                    UmlautMobius.String, MessageBoxButtons.OK, MessageBoxIcon.Information);
                return(false);
            }

            if (q.KeyCriteria.ToLower().IndexOf("in list current") >= 0 || Lex.Contains(q.KeyCriteria, "in list " + UserObject.TempFolderNameQualified))
            {
                MessageBoxMx.Show(
                    "An alert cannot be defined on this query because it uses a volatile temporary list criteria.\n" +
                    "If you save the temporary list and then use this saved list as the criteria then you can define an alert on the query.",
                    UmlautMobius.String, MessageBoxButtons.OK, MessageBoxIcon.Information);
                return(false);
            }

            return(true);
        }
Beispiel #12
0
/// <summary>
/// Show import menu
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>

        private void ImportFileButton_Click(object sender, EventArgs e)
        {
            if (!AllowColumnModifications())
            {
                return;
            }

            if (Dtm.DataModified)
            {
                MessageBoxMx.ShowError("You must save the current changes to the data before you can import a new file.");
                return;
            }

            if (ImportFileContextMenu.Tag == null)
            {
                ImportFileContextMenu.Show(ImportFileButton,
                                           new System.Drawing.Point(0, ImportFileButton.Size.Height));
            }

            else
            {
                ImportUcdbContextMenu.Show(ImportFileButton,
                                           new System.Drawing.Point(0, ImportFileButton.Size.Height));
            }

            return;
        }
Beispiel #13
0
        private void MoveColumnDown_Click(object sender, EventArgs e)
        {
            if (!AllowColumnModifications())
            {
                return;
            }

            int r = View.FocusedRowHandle;

            if (r < 0)
            {
                return;
            }
            if ((AnnotationTable && r <= 0) || (UserDatabase && r <= 1) ||             // keep initial col position(s) as is
                r >= View.RowCount - 1)
            {
                MessageBoxMx.Show("This column can't be moved down.");
                return;
            }

            DataRow dr = ColGridDataTable.NewRow();

            dr.ItemArray = ColGridDataTable.Rows[r].ItemArray;
            ColGridDataTable.Rows.RemoveAt(r);
            ColGridDataTable.Rows.InsertAt(dr, r + 1);
            View.FocusedRowHandle = r + 1;
            return;
        }
Beispiel #14
0
        internal void ZoomMenuItem_Click(object sender, EventArgs e)
        {
            ActivateZooming();

            string msg =
                @"To zoom in:
  - Hold down the Shift key and then click on the point to zoom in to or
  - Hold down the Shift key and then draw a rectangle around the 
    area to zoom in to or
  - Hold down the Ctrl key and click the plus (+) key or
  - Use the mouse wheel

To zoom out:
  - Hold down the Alt key and then click in the region to be zoomed out or
  - Hold down the Ctrl key and click the minus (-) key or
  - Use the mouse wheel

To scroll:
  - Use the scroll bars or
  - Hold down the Space key and then press and drag with the mouse or
  - Hold down the Ctrl key and then use the cursor (arrow) keys";

            MessageBoxMx.Show(msg);
            return;
        }
Beispiel #15
0
        /// <summary>
        /// Click function to open an external web site when clicking on a CID in a SmallWorld database display
        /// </summary>
        /// <param name="args"></param>

        public static void OpenUrlFromSmallWorldCid(
            string cid)
        {
            string[] px = { "PBCHM", "PDB" };

            RootTable rt = CompoundId.GetRootTableFromCid(cid);

            if (rt == null || Lex.IsUndefined(rt.CidUrl))
            {
                if (rt != null && Lex.Contains(rt.MetaTableName, MetaTable.PrimaryRootTable))
                {
                    RelatedCompoundsDialog.Show(cid);
                    return;
                }

                MessageBoxMx.ShowError("Unable to determine url link for compound Id: " + cid);
                return;
            }

            string url = rt.CidUrl;

            foreach (string p in px)             // remove unwanted URLs
            {
                if (Lex.StartsWith(cid, p))
                {
                    cid = cid.Substring(p.Length);
                }
            }

            url = Lex.Replace(url, "[CID]", cid);
            SystemUtil.StartProcess(url);
            return;
        }
Beispiel #16
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
            }
        }
Beispiel #17
0
/// <summary>
/// Run alert in background
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>

        private void RunAlert_Click(object sender, EventArgs e)
        {
            int    row, alertId;
            string msg = "";

            row = V.GetFocusedDataSourceRowIndex();
            if (row < 0)
            {
                return;
            }
            alertId = (int)DataTable.Rows[row]["AlertId"];

            string command = "Check Alert " + alertId + " forceEmail";

            try
            {
                CommandLine.StartBackgroundSession(command);
                msg =
                    "The Alert has been started in the background.\n" +
                    "You will receive an email when it completes.";
            }
            catch (Exception ex)
            {
                msg = "Failed to start background alert: " + ex.Message;
            }

            MessageBoxMx.Show(msg);

            return;
        }
Beispiel #18
0
/// <summary>
/// Change owner
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>

        private void ChangeOwnerMenuItem_Click(object sender, EventArgs e)
        {
            {
                List <string> users    = SecurityUtil.GetAllUsers();
                string        prompt   = "Enter the user name of the person to transfer ownership of " + Lex.AddDoubleQuotes(Uo.Name) + " to:";
                string        newOwner = InputBoxMx.Show(prompt, "Change Owner", "", users, -1, -1);
                if (Lex.IsNullOrEmpty(newOwner))
                {
                    return;
                }

                string newUserName = SecurityUtil.GetInternalUserName(newOwner);
                if (Lex.IsNullOrEmpty(newUserName))
                {
                    return;
                }

                string result = UserObjectUtil.ChangeOwner(Uo.Id, newUserName);
                if (!Lex.IsNullOrEmpty(result))
                {
                    MessageBoxMx.Show(result);
                    DialogResult = DialogResult.Cancel;                     // close the dialog
                }
                return;
            }
        }
Beispiel #19
0
        /// <summary>
        /// Run Query & return any error message
        /// </summary>
        /// <param name="query"></param>
        /// <param name="queryDest"></param>
        /// <param name="outputFormContext"></param>
        /// <param name="browseExistingResults">If true browse existing results</param>
        /// <param name="suppressNoDataMessage"></param>
        /// <returns>Command command or an error message</command></returns>

        public static string RunQuery(
            Query query,
            OutputDest outputDest,
            OutputFormContext outputFormContext,
            ExitingQueryResultsDelegate exitingQueryResultsCallBack = null,
            bool browseExistingResults = false,
            bool suppressNoDataMessage = false
            )
        {
            ResultsFormat rf = new ResultsFormat();

            rf.OutputDestination = outputDest;
            rf.OutputFormContext = outputFormContext;
            rf.CustomExitingQueryResultsCallback = exitingQueryResultsCallBack;
            rf.SuppressNoDataMessage             = suppressNoDataMessage;

            string response = RunQuery2(query, rf, browseExistingResults);

            query.UseResultKeys = false;             // turn off use of keys

            if (response != "" && !response.ToLower().StartsWith("command") && !suppressNoDataMessage)
            {
                MessageBoxMx.Show(
                    response, UmlautMobius.String,
                    MessageBoxButtons.OK, MessageBoxIcon.Information);

                response = "Command EditQuery";
            }

            return(response);
        }
Beispiel #20
0
        /// <summary>
        /// Show with up to 4 custom buttons
        /// </summary>
        /// <param name="message"></param>
        /// <param name="caption"></param>
        /// <param name="button1"></param>
        /// <param name="button2"></param>
        /// <param name="button3"></param>
        /// <param name="button4"></param>
        /// <param name="icon"></param>
        /// <returns>Value of 1 - 4 corresponding to button pressed </returns>

        public static int ShowWithCustomButtons(
            string message,
            string caption,
            string button1,
            string button2,
            string button3,
            string button4,
            MessageBoxIcon icon,
            int width  = -1,
            int height = -1)
        {
            if (!SS.I.Attended)
            {
                ClientLog.Message("Show: " + message);
                return((int)DialogResult.OK);
            }

            Progress.Hide(); // hide any progress message

            MessageBoxMx mb = new MessageBoxMx();

            if (JupyterGuiConverter.ConversionsEnabled)
            {
                MessageBoxMx2 mb2 = new MessageBoxMx2();
                new JupyterGuiConverter().ConvertFormOrUserControl(mb2);
            }

            int rc = mb.ShowInstance(message, caption, button1, button2, button3, button4, icon, width, height);

            return(rc);
        }
Beispiel #21
0
/// <summary>
/// See if valid basic calculated field
/// </summary>
/// <returns></returns>

        private bool IsValidBasicCalcField()
        {
            for (int cfcci = 0; cfcci < CfColCtls.Count; cfcci++)
            {
                CalcFieldColumnControl cfcc = CfColCtls[cfcci];

                bool validate = false;                 // decide if we should validate this field

                if (cfcci == 0)
                {
                    validate = true;                             // always validate 1st field
                }
                else if (cfcci == 1 && !Lex.StartsWith(Operation.Text, "none"))
                {
                    validate = true;                                                                             // validate 2nd field if operator is not "none"
                }
                else if (cfcc.FieldSelectorControl.MetaColumn != null)
                {
                    validate = true;
                }

                if (validate && !ValidateField(cfcc))
                {
                    return(false);
                }
            }

            if (!CondFormatRulesCtl.AreValid())             // are any rules valid
            {
                Tabs.SelectedTabPageIndex = 1;
                return(false);
            }

            CondFormatRules rules = CondFormatRulesCtl.GetRules();

            if (CalcField.SourceColumnType == MetaColumnType.Structure && rules.Count == 0)
            {
                Tabs.SelectedTabPageIndex = 1;
                MessageBoxMx.Show(
                    "Calculated fields on chemical structures must use classification\r\n" +
                    "for the calculated field value", UmlautMobius.String);
                return(false);
            }

            if (rules.Count > 0)             // must have at least one rule

            {
                foreach (CondFormatRule rule in rules)         // must have name for each rule
                {
                    if (String.IsNullOrEmpty(rule.Name))
                    {
                        Tabs.SelectedTabPageIndex = 1;
                        MessageBoxMx.Show("A name must be defined for each rule if using rule names the as calculated value", UmlautMobius.String);
                        return(false);
                    }
                }
            }

            return(true);
        }
Beispiel #22
0
        private void BrowseQueries_Click(object sender, EventArgs e)
        {
            string     prompt = "Select Query";
            UserObject uo     = UserObjectOpenDialog.ShowDialog(UserObjectType.Query, prompt, QueryUo);

            if (uo == null)
            {
                return;
            }
            Alert existingAlert = Alert.GetAlertByQueryId(uo.Id);

            if (existingAlert != null)                              // only 1 alert per query per user is allowed
            {
                if (Alert.Id <= 0 ||                                // if this is a new alert or
                    (Alert.Id > 0 && Alert.Id != existingAlert.Id)) // another alert exists for the query
                {
                    MessageBoxMx.Show("You already an existing alert for query " + Lex.Dq(uo.Name),
                                      "Mobius", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
            }

            Query q = QbUtil.ReadQuery(uo.Id);

            if (!Alert.QueryValidForAlert(q))
            {
                return;
            }

            QueryUo        = uo;
            QueryName.Text = QueryUo.Name;
        }
Beispiel #23
0
        /// <summary>
        /// Load the root xml document and call the control's SetData method.  Register for the control's AfterTreeUpdate
        /// method so we can enable/disable various buttons.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ContentsTreeEditorDialog_Load(object sender, EventArgs e)
        {
            XmlDocument rootXml = new XmlDocument();
            string      msg     = "Begin \r\n\r\n";

            try
            {
                string treeXml = MetaTreeFactory.LockAndReadMetatreeXml();
                msg += string.IsNullOrEmpty(treeXml) ? "treeXml is null" : "treeXml is not null";
                msg += "\r\n\r\n";
                rootXml.LoadXml(treeXml);
                msg += "LoadXml success \r\n\r\n";
                contentsTreeEditorControl1.SetData(rootXml);
                msg += "SetData success \r\n\r\n";
                if (!string.IsNullOrEmpty(_fullNodePath))
                {
                    msg += "_fullNodePath is not null: " + _fullNodePath + " \r\n\r\n";
                    msg += (contentsTreeEditorControl1 == null) ? "contentsTreeEditorControl1 is null" : "contentsTreeEditorControl1 is not null";
                    msg += "SetData success \r\n\r\n";
                    contentsTreeEditorControl1.SetCurrentNode(_fullNodePath);
                }
                if (contentsTreeEditorControl1 == null)
                {
                    msg += "contentsTreeEditorControl1 is null \r\n\r\n";
                }
                contentsTreeEditorControl1.AfterTreeUpdate += AfterTreeUpdate;
            }
            catch (Exception ex)
            {
                msg += "Unable to open the database contents tree for editing.\r\n\r\n" + ex.Message;
                MessageBoxMx.ShowError(msg);
                Close();
            }
        }
Beispiel #24
0
        /// <summary>
        /// If the file is a UNC name check to see if the services can write to it
        /// </summary>
        /// <param name="fileName"></param>

        public static DialogResult CanWriteFileFromServiceAccount(
            string fileName)
        {
            //if (DisplayedUncWarningMessage) return DialogResult.OK;

            if (!fileName.StartsWith(@"\\"))
            {
                return(DialogResult.OK);
            }
            ;

            Progress.Show("Checking Mobius background write privileges...", UmlautMobius.String, false);
            bool canWrite = ServerFile.CanWriteFileFromServiceAccount(fileName);

            Progress.Hide();
            //canWrite = false; // debug
            if (canWrite)
            {
                return(DialogResult.OK);
            }

            DialogResult dr = MessageBoxMx.Show(
                "The specified file is in a shared Windows network folder.\n" +
                "Mobius can't currently perform a background export directly to this file.\n" +
                "However, if write access to this shared folder is granted to the <mobiusAccount>\n" +
                "account then Mobius will be able to export directly to the specified file.",
                "Mobius", MessageBoxButtons.OKCancel, MessageBoxIcon.Information);

            DisplayedUncWarningMessage = true;
            return(dr);
        }
Beispiel #25
0
        /// <summary>
        /// Create the view display controls and link them into the QueryResultsControl and the ResultsView object
        /// </summary>
        /// <returns></returns>

        public override Control AllocateRenderingControl()
        {
            if (RealizeSubQueryView() == null)             // be sure the subquery and view still exist
            {
                MessageBoxMx.ShowError("Failed to realize SubQueryId: " + SubQueryId + ", SubQuerySelectedViewId: " + SubQuerySelectedViewId);
                return(null);
            }

            Query            sq     = SubQuery;
            ResultsViewProps sqView = SubQuerySelectedView;

            if (Lex.IsUndefined(CustomViewTypeImageName))
            {
                CustomViewTypeImageName = sqView.CustomViewTypeImageName;
            }

            if (Lex.IsUndefined(Title))
            {
                Title = sqView.Title;
            }

            if (Sqm == null)
            {
                Sqm = SetupAndExecuteSecondaryQuery(sq, sqView);
            }

            RenderingControl = sqView.AllocateRenderingControl();             // allocate proper control for the subquery view we want to use

            return(RenderingControl);
        }
Beispiel #26
0
        /// <summary>
        /// See if client file can be opened for writing to default dir and optionally display error message if not
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>

        public static bool CanWriteFileToDefaultDir(
            string fileName)
        {
            if (!Directory.Exists(ClientDirs.DefaultMobiusUserDocumentsFolder))
            {
                MessageBoxMx.ShowError(
                    "Unable to write to your default import/export folder: \"" + ClientDirs.DefaultMobiusUserDocumentsFolder + "\"\n\n" +
                    "You can change your default folder if necessary with the Tools > Preferences command");

                return(false);
            }

            string msg = FileUtil.CanWriteFile(fileName);

            if (msg == "")
            {
                return(true);
            }
            MessageBoxMx.ShowError(
                "Unable to write file \"" + fileName + "\"to your Mobius default folder: \"" + ClientDirs.DefaultMobiusUserDocumentsFolder + "\"\n\n" +
                "Error message: " + msg + "\n\n" +
                "You can change your default folder if necessary with the Tools > Preferences command");

            return(false);
        }
Beispiel #27
0
        /// <summary>
        /// Read in focused UserObject
        /// </summary>
        /// <param name="ri"></param>
        /// <param name="dr"></param>
        /// <param name="ucdb"></param>
        /// <param name="uo"></param>
        /// <returns></returns>

        bool GetFocusedUo(out int ri, out DataRow dr, out UcdbDatabase ucdb, out UserObject uo)
        {
            dr   = null;
            ucdb = null;
            uo   = null;

            ri = GridView.FocusedRowHandle;


            if (ri < 0)
            {
                MessageBoxMx.ShowError("You must select the user compound database first");
                return(false);
            }

            dr   = DataTable.Rows[ri];
            ucdb = (UcdbDatabase)dr["Ucdb"];

            uo = UserObjectDao.Read(UserObjectType.UserDatabase, ucdb.OwnerUserName, ucdb.NameSpace, ucdb.Name);
            if (uo == null)
            {
                MessageBoxMx.ShowError("Unable to find associated user database \"UserObject\" information");
                return(false);
            }

            return(true);
        }
Beispiel #28
0
        /// <summary>
        /// See if client file can be opened for writing and optionally display error message if not
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>

        public static bool CanWriteFile(
            string fileName,
            bool showErrorIfCantWrite)
        {
            string msg = "";

            if (!Lex.StartsWith(fileName, "http"))
            {
                msg = FileUtil.CanWriteFile(fileName);
                if (msg == "")
                {
                    return(true);
                }
            }

            else              // URL
            {
                return(true); // todo: really check
            }

            if (showErrorIfCantWrite)
            {
                MessageBoxMx.ShowError(
                    "Can't open file for writing: " + fileName + "\n" + msg);
            }
            return(false);
        }
Beispiel #29
0
        /// <summary>
        /// Allow user to edit the form
        /// </summary>
        /// <returns></returns>

        public static bool Edit(
            QueryColumn qc)
        {
            if (InEdit)
            {
                return(false);                    // prevent reentry via multiple clicks on the edit button
            }
            InEdit = true;

            try
            {
                if (!SS.I.UserInfo.Privileges.CanRetrieveStructures)
                {
                    MessageBoxMx.ShowError("Structure Access Not Authorized");
                    return(false);
                }

                //if (Instance == null) // use single instance
                Instance = new CriteriaStructure();

                Instance.SetupForm(qc);

                DialogResult dr = Instance.ShowDialog(SessionManager.ActiveForm);
                if (dr == DialogResult.OK)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            finally { InEdit = false; }
        }
Beispiel #30
0
        /// <summary>
        /// Build a basic database query for the user database
        /// </summary>
        /// <param name="uo"></param>
        /// <returns></returns>

        internal static bool BuildDatabaseQuery(
            UserObject uo)
        {
            List <UserObject> luo = UserDataEditor.GetUcdbUserObjects(uo.Id);

            if (luo == null || luo.Count == 0)
            {
                MessageBoxMx.ShowError("No tables found for database");
                return(false);
            }

            Query q = new Query();

            foreach (UserObject uo2 in luo)
            {
                if (!UserObject.IsMetaTableType(uo2.Type))
                {
                    continue;
                }

                string    mtName = uo2.Type.ToString() + "_" + uo2.Id;
                MetaTable mt     = MetaTableCollection.Get(mtName);
                if (mt == null)
                {
                    continue;
                }
                QueryTable qt = new QueryTable(mt);
                q.AddQueryTable(qt);
            }

            QbUtil.NewQuery(uo.Name);
            QbUtil.SetCurrentQueryInstance(q);
            return(true);
        }